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

"""

    32

import time

    33

import features

    34

import shutil

    35

import wx

    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

def ExtractChildrenTypesFromCatalog(catalog):

    71

    children_types = []

    72

    for n,d,h,c in catalog:

    73

        if isinstance(c, ListType):

    74

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    75

        else:

    76

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

    77

    return children_types

    78

    79

def ExtractMenuItemsFromCatalog(catalog):

    80

    menu_items = []

    81

    for n,d,h,c in catalog:

    82

        if isinstance(c, ListType):

    83

            children = ExtractMenuItemsFromCatalog(c)

    84

        else:

    85

            children = []

    86

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

    87

    return menu_items

    88

    89

def GetAddMenuItems():

    90

    return ExtractMenuItemsFromCatalog(features.catalog)

    91

    92

class Iec2CSettings():

    93

    def __init__(self):

    94

        self.iec2c = None

    95

        self.iec2c_buildopts = None

    96

        self.ieclib_path   = self.findLibPath()

    97

        self.ieclib_c_path = self.findLibCPath()

    98

    99

    def findObject(self, paths, test):

   100

        path=None

   101

        for p in paths:

   102

            if test(p):

   103

                path = p

   104

                break

   105

        return path

   106

   107

    def findCmd(self):

   108

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

   109

        paths=[

   110

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

   111

        ]

   112

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

   113

   114

        # otherwise use iec2c from PATH

   115

        if path is not None:

   116

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

   117

   118

        return cmd

   119

   120

    def findLibPath(self):

   121

        paths=[

   122

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

   123

            "/usr/lib/matiec"

   124

        ]

   125

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

   126

        return path

   127

   128

    def findLibCPath(self):

   129

        path=None

   130

        paths=[

   131

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

   132

            self.ieclib_path]

   133

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

   134

        return path

   135

   136

    def findSupportedOptions(self):

   137

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

   138

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

   139

   140

        buildopt = ""

   141

        try:

   142

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

   143

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

   144

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

   145

        except Exception,e:

   146

            return buildopt

   147

   148

        for opt in options:

   149

            if opt in result:

   150

                buildopt = buildopt + " " + opt

   151

        return buildopt

   152

   153

    def getCmd(self):

   154

        if self.iec2c is None:

   155

            self.iec2c = self.findCmd()

   156

        return self.iec2c

   157

   158

    def getOptions(self):

   159

        if self.iec2c_buildopts is None:

   160

            self.iec2c_buildopts = self.findSupportedOptions()

   161

        return self.iec2c_buildopts

   162

   163

    def getLibPath(self):

   164

        return self.ieclib_path

   165

   166

    def getLibCPath(self):

   167

        if self.ieclib_c_path is None:

   168

            self.ieclib_c_path = self.findLibCPath()

   169

        return self.ieclib_c_path

   170

   171

iec2c_cfg = Iec2CSettings()

   172

   173

class ProjectController(ConfigTreeNode, PLCControler):

   174

    """

   175

    This class define Root object of the confnode tree.

   176

    It is responsible of :

   177

    - Managing project directory

   178

    - Building project

   179

    - Handling PLCOpenEditor controler and view

   180

    - Loading user confnodes and instanciante them as children

   181

    - ...

   182

   183

    """

   184

   185

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

   186

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   187

   188

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

   189

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

   190

      <xsd:element name="BeremizRoot">

   191

        <xsd:complexType>

   192

          <xsd:sequence>

   193

            <xsd:element name="TargetType">

   194

              <xsd:complexType>

   195

                <xsd:choice minOccurs="0">

   196

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

   197

                </xsd:choice>

   198

              </xsd:complexType>

   199

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

   200

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

   201

              <xsd:complexType>

   202

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

   203

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

   204

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

   205

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

   206

              </xsd:complexType>

   207

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

   208

          </xsd:sequence>

   209

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

   210

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

   211

        </xsd:complexType>

   212

      </xsd:element>

   213

    </xsd:schema>

   214

    """

   215

    EditorType = ProjectNodeEditor

   216

   217

    def __init__(self, frame, logger):

   218

        PLCControler.__init__(self)

   219

   220

        self.MandatoryParams = None

   221

        self._builder = None

   222

        self._connector = None

   223

        self.DispatchDebugValuesTimer = None

   224

        self.DebugValuesBuffers = []

   225

        self.DebugTicks = []

   226

        self.SetAppFrame(frame, logger)

   227

   228

        # Setup debug information

   229

        self.IECdebug_datas = {}

   230

        self.IECdebug_lock = Lock()

   231

   232

        self.DebugTimer=None

   233

        self.ResetIECProgramsAndVariables()

   234

   235

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

   236

        self.ChangesToSave = False

   237

        # root have no parent

   238

        self.CTNParent = None

   239

        # Keep track of the confnode type name

   240

        self.CTNType = "Beremiz"

   241

        self.Children = {}

   242

        self._View = None

   243

        # After __init__ root confnode is not valid

   244

        self.ProjectPath = None

   245

        self._setBuildPath(None)

   246

        self.DebugThread = None

   247

        self.debug_break = False

   248

        self.previous_plcstate = None

   249

        # copy ConfNodeMethods so that it can be later customized

   250

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

   251

   252

    def __del__(self):

   253

        if self.DebugTimer:

   254

            self.DebugTimer.cancel()

   255

        self.KillDebugThread()

   256

   257

    def LoadLibraries(self):

   258

        self.Libraries = []

   259

        TypeStack=[]

   260

        for libname,clsname in features.libraries:

   261

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

   262

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

   263

                TypeStack.append(Lib.GetTypes())

   264

                self.Libraries.append(Lib)

   265

   266

    def SetAppFrame(self, frame, logger):

   267

        self.AppFrame = frame

   268

        self.logger = logger

   269

        self.StatusTimer = None

   270

        if self.DispatchDebugValuesTimer is not None:

   271

            self.DispatchDebugValuesTimer.Stop()

   272

        self.DispatchDebugValuesTimer = None

   273

   274

        if frame is not None:

   275

   276

            # Timer to pull PLC status

   277

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

   278

            self.AppFrame.Bind(wx.EVT_TIMER,

   279

                self.PullPLCStatusProc, self.StatusTimer)

   280

   281

            if self._connector is not None:

   282

                frame.LogViewer.SetLogSource(self._connector)

   283

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

   284

   285

            # Timer to dispatch debug values to consumers

   286

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

   287

            self.AppFrame.Bind(wx.EVT_TIMER,

   288

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   289

   290

            self.RefreshConfNodesBlockLists()

   291

   292

    def ResetAppFrame(self, logger):

   293

        if self.AppFrame is not None:

   294

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

   295

            self.StatusTimer = None

   296

            self.AppFrame = None

   297

   298

        self.logger = logger

   299

   300

    def CTNName(self):

   301

        return "Project"

   302

   303

    def CTNTestModified(self):

   304

         return self.ChangesToSave or not self.ProjectIsSaved()

   305

   306

    def CTNFullName(self):

   307

        return ""

   308

   309

    def GetCTRoot(self):

   310

        return self

   311

   312

    def GetIECLibPath(self):

   313

        return iec2c_cfg.getLibCPath()

   314

   315

    def GetIEC2cPath(self):

   316

        return iec2c_cfg.getCmd()

   317

   318

    def GetCurrentLocation(self):

   319

        return ()

   320

   321

    def GetCurrentName(self):

   322

        return ""

   323

   324

    def _GetCurrentName(self):

   325

        return ""

   326

   327

    def GetProjectPath(self):

   328

        return self.ProjectPath

   329

   330

    def GetProjectName(self):

   331

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

   332

   333

    def GetIconName(self):

   334

        return "PROJECT"

   335

   336

    def GetDefaultTargetName(self):

   337

        if wx.Platform == '__WXMSW__':

   338

            return "Win32"

   339

        else:

   340

            return "Linux"

   341

   342

    def GetTarget(self):

   343

        target = self.BeremizRoot.getTargetType()

   344

        if target.getcontent() is None:

   345

            temp_root = self.Parser.CreateRoot()

   346

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

   347

            temp_root.setTargetType(target)

   348

            target_name = self.GetDefaultTargetName()

   349

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

   350

        return target

   351

   352

    def GetParamsAttributes(self, path = None):

   353

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   354

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

   355

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

   356

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

   357

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

   358

        return params

   359

   360

    def SetParamsAttribute(self, path, value):

   361

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

   362

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

   363

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

   364

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

   365

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   366

        return res

   367

   368

    # helper func to check project path write permission

   369

    def CheckProjectPathPerm(self, dosave=True):

   370

        if CheckPathPerm(self.ProjectPath):

   371

            return True

   372

        if self.AppFrame is not None:

   373

            dialog = wx.MessageDialog(self.AppFrame,

   374

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

   375

                        _('Error'),

   376

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

   377

            answer = dialog.ShowModal()

   378

            dialog.Destroy()

   379

            if answer == wx.ID_YES:

   380

                if self.SaveProjectAs():

   381

                    self.AppFrame.RefreshTitle()

   382

                    self.AppFrame.RefreshFileMenu()

   383

                    self.AppFrame.RefreshPageTitles()

   384

                    return True

   385

        return False

   386

   387

    def _getProjectFilesPath(self, project_path=None):

   388

        if project_path is not None:

   389

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

   390

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

   391

        if not os.path.exists(projectfiles_path):

   392

            os.mkdir(projectfiles_path)

   393

        return projectfiles_path

   394

   395

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

   396

        self.ProjectAddConfiguration(config_name)

   397

        self.ProjectAddConfigurationResource(config_name, res_name)

   398

   399

    def SetProjectDefaultConfiguration(self):

   400

        # Sets default task and instance for new project

   401

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

   402

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

   403

        config = config.getname()

   404

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   405

        def_task = [

   406

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

   407

        def_instance = [

   408

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

   409

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   410

   411

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

   412

        """

   413

        Create a new project in an empty folder

   414

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

   415

        @param PLCParams: properties of the PLCOpen program created

   416

        """

   417

        # Verify that chosen folder is empty

   418

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

   419

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

   420

   421

        # Create PLCOpen program

   422

        self.CreateNewProject(

   423

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

   424

             "productName": _("Unnamed"),

   425

             "productVersion": "1",

   426

             "companyName": _("Unknown"),

   427

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

   428

        self.AddProjectDefaultConfiguration()

   429

   430

        # Change XSD into class members

   431

        self._AddParamsMembers()

   432

        self.Children = {}

   433

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

   434

        self.ProjectPath = ProjectPath

   435

        self._setBuildPath(BuildPath)

   436

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

   437

        self.RefreshConfNodesBlockLists()

   438

        # this will create files base XML files

   439

        self.SaveProject()

   440

        return None

   441

   442

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

   443

        """

   444

        Load a project contained in a folder

   445

        @param ProjectPath: path of the project folder

   446

        """

   447

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

   448

            ProjectPath = os.path.dirname(ProjectPath)

   449

        # Verify that project contains a PLCOpen program

   450

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

   451

        if not os.path.isfile(plc_file):

   452

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

   453

        # Load PLCOpen file

   454

        error = self.OpenXMLFile(plc_file)

   455

        if error is not None:

   456

            if self.Project is not None:

   457

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

   458

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

   459

            else:

   460

                return error, False

   461

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

   462

            self.AddProjectDefaultConfiguration()

   463

        # Change XSD into class members

   464

        self._AddParamsMembers()

   465

        self.Children = {}

   466

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

   467

        self.ProjectPath = ProjectPath

   468

        self._setBuildPath(BuildPath)

   469

        # If dir have already be made, and file exist

   470

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

   471

            #Load the confnode.xml file into parameters members

   472

            result = self.LoadXMLParams()

   473

            if result:

   474

                return result, False

   475

            #Load and init all the children

   476

            self.LoadChildren()

   477

        self.RefreshConfNodesBlockLists()

   478

        self.UpdateButtons()

   479

        return None, False

   480

   481

    def RecursiveConfNodeInfos(self, confnode):

   482

        values = []