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

     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

    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

    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 = os.path.join(base_folder, "matiec", "iec2c"+(".exe" if wx.Platform == '__WXMSW__' else ""))

    92

        self.iec2c_buildopts = None

    93

        self.ieclib_path   = os.path.join(base_folder, "matiec", "lib")

    94

        self.ieclib_c_path = None

    95

    96

    def findLibCPath(self):

    97

        path=""

    98

        paths=[

    99

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

   100

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

   101

        for p in paths:

   102

            filename=os.path.join(p, "iec_types.h")

   103

            if (os.path.isfile(filename)):

   104

                path = p

   105

                break

   106

        return path

   107

   108

    def findSupportedOptions(self):

   109

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

   110

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

   111

   112

        buildopt = ""

   113

        try:

   114

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

   115

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

   116

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

   117

        except Exception,e:

   118

            return buildopt

   119

   120

        for opt in options:

   121

            if opt in result:

   122

                buildopt = buildopt + " " + opt

   123

        return buildopt

   124

   125

    def getCmd(self):

   126

        return self.iec2c

   127

   128

    def getOptions(self):

   129

        if self.iec2c_buildopts is None:

   130

            self.iec2c_buildopts = self.findSupportedOptions()

   131

        return self.iec2c_buildopts

   132

   133

    def getLibPath(self):

   134

        return self.ieclib_path

   135

   136

    def getLibCPath(self):

   137

        if self.ieclib_c_path is None:

   138

            self.ieclib_c_path = self.findLibCPath()

   139

        return self.ieclib_c_path

   140

   141

iec2c_cfg = Iec2CSettings()

   142

   143

class ProjectController(ConfigTreeNode, PLCControler):

   144

    """

   145

    This class define Root object of the confnode tree.

   146

    It is responsible of :

   147

    - Managing project directory

   148

    - Building project

   149

    - Handling PLCOpenEditor controler and view

   150

    - Loading user confnodes and instanciante them as children

   151

    - ...

   152

   153

    """

   154

   155

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

   156

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   157

   158

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

   159

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

   160

      <xsd:element name="BeremizRoot">

   161

        <xsd:complexType>

   162

          <xsd:sequence>

   163

            <xsd:element name="TargetType">

   164

              <xsd:complexType>

   165

                <xsd:choice minOccurs="0">

   166

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

   167

                </xsd:choice>

   168

              </xsd:complexType>

   169

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

   170

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

   171

              <xsd:complexType>

   172

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

   173

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

   174

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

   175

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

   176

              </xsd:complexType>

   177

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

   178

          </xsd:sequence>

   179

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

   180

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

   181

        </xsd:complexType>

   182

      </xsd:element>

   183

    </xsd:schema>

   184

    """

   185

    EditorType = ProjectNodeEditor

   186

   187

    def __init__(self, frame, logger):

   188

        PLCControler.__init__(self)

   189

   190

        self.MandatoryParams = None

   191

        self._builder = None

   192

        self._connector = None

   193

        self.DispatchDebugValuesTimer = None

   194

        self.DebugValuesBuffers = []

   195

        self.DebugTicks = []

   196

        self.SetAppFrame(frame, logger)

   197

   198

        # Setup debug information

   199

        self.IECdebug_datas = {}

   200

        self.IECdebug_lock = Lock()

   201

   202

        self.DebugTimer=None

   203

        self.ResetIECProgramsAndVariables()

   204

   205

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

   206

        self.ChangesToSave = False

   207

        # root have no parent

   208

        self.CTNParent = None

   209

        # Keep track of the confnode type name

   210

        self.CTNType = "Beremiz"

   211

        self.Children = {}

   212

        self._View = None

   213

        # After __init__ root confnode is not valid

   214

        self.ProjectPath = None

   215

        self._setBuildPath(None)

   216

        self.DebugThread = None

   217

        self.debug_break = False

   218

        self.previous_plcstate = None

   219

        # copy ConfNodeMethods so that it can be later customized

   220

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

   221

   222

    def __del__(self):

   223

        if self.DebugTimer:

   224

            self.DebugTimer.cancel()

   225

        self.KillDebugThread()

   226

   227

    def LoadLibraries(self):

   228

        self.Libraries = []

   229

        TypeStack=[]

   230

        for libname,clsname in features.libraries:

   231

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

   232

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

   233

                TypeStack.append(Lib.GetTypes())

   234

                self.Libraries.append(Lib)

   235

   236

    def SetAppFrame(self, frame, logger):

   237

        self.AppFrame = frame

   238

        self.logger = logger

   239

        self.StatusTimer = None

   240

        if self.DispatchDebugValuesTimer is not None:

   241

            self.DispatchDebugValuesTimer.Stop()

   242

        self.DispatchDebugValuesTimer = None

   243

   244

        if frame is not None:

   245

   246

            # Timer to pull PLC status

   247

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

   248

            self.AppFrame.Bind(wx.EVT_TIMER,

   249

                self.PullPLCStatusProc, self.StatusTimer)

   250

   251

            if self._connector is not None:

   252

                frame.LogViewer.SetLogSource(self._connector)

   253

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

   254

   255

            # Timer to dispatch debug values to consumers

   256

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

   257

            self.AppFrame.Bind(wx.EVT_TIMER,

   258

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   259

   260

            self.RefreshConfNodesBlockLists()

   261

   262

    def ResetAppFrame(self, logger):

   263

        if self.AppFrame is not None:

   264

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

   265

            self.StatusTimer = None

   266

            self.AppFrame = None

   267

   268

        self.logger = logger

   269

   270

    def CTNName(self):

   271

        return "Project"

   272

   273

    def CTNTestModified(self):

   274

         return self.ChangesToSave or not self.ProjectIsSaved()

   275

   276

    def CTNFullName(self):

   277

        return ""

   278

   279

    def GetCTRoot(self):

   280

        return self

   281

   282

    def GetIECLibPath(self):

   283

        return iec2c_cfg.getLibCPath()

   284

   285

    def GetIEC2cPath(self):

   286

        return iec2c_cfg.getCmd()

   287

   288

    def GetCurrentLocation(self):

   289

        return ()

   290

   291

    def GetCurrentName(self):

   292

        return ""

   293

   294

    def _GetCurrentName(self):

   295

        return ""

   296

   297

    def GetProjectPath(self):

   298

        return self.ProjectPath

   299

   300

    def GetProjectName(self):

   301

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

   302

   303

    def GetIconName(self):

   304

        return "PROJECT"

   305

   306

    def GetDefaultTargetName(self):

   307

        if wx.Platform == '__WXMSW__':

   308

            return "Win32"

   309

        else:

   310

            return "Linux"

   311

   312

    def GetTarget(self):

   313

        target = self.BeremizRoot.getTargetType()

   314

        if target.getcontent() is None:

   315

            temp_root = self.Parser.CreateRoot()

   316

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

   317

            temp_root.setTargetType(target)

   318

            target_name = self.GetDefaultTargetName()

   319

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

   320

        return target

   321

   322

    def GetParamsAttributes(self, path = None):

   323

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   324

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

   325

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

   326

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

   327

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

   328

        return params

   329

   330

    def SetParamsAttribute(self, path, value):

   331

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

   332

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

   333

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

   334

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

   335

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   336

        return res

   337

   338

    # helper func to check project path write permission

   339

    def CheckProjectPathPerm(self, dosave=True):

   340

        if CheckPathPerm(self.ProjectPath):

   341

            return True

   342

        if self.AppFrame is not None:

   343

            dialog = wx.MessageDialog(self.AppFrame,

   344

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

   345

                        _('Error'),

   346

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

   347

            answer = dialog.ShowModal()

   348

            dialog.Destroy()

   349

            if answer == wx.ID_YES:

   350

                if self.SaveProjectAs():

   351

                    self.AppFrame.RefreshTitle()

   352

                    self.AppFrame.RefreshFileMenu()

   353

                    self.AppFrame.RefreshPageTitles()

   354

                    return True

   355

        return False

   356

   357

    def _getProjectFilesPath(self, project_path=None):

   358

        if project_path is not None:

   359

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

   360

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

   361

        if not os.path.exists(projectfiles_path):

   362

            os.mkdir(projectfiles_path)

   363

        return projectfiles_path

   364

   365

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

   366

        self.ProjectAddConfiguration(config_name)

   367

        self.ProjectAddConfigurationResource(config_name, res_name)

   368

   369

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

   370

        """

   371

        Create a new project in an empty folder

   372

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

   373

        @param PLCParams: properties of the PLCOpen program created

   374

        """

   375

        # Verify that chosen folder is empty

   376

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

   377

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

   378

   379

        # Create PLCOpen program

   380

        self.CreateNewProject(

   381

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

   382

             "productName": _("Unnamed"),

   383

             "productVersion": "1",

   384

             "companyName": _("Unknown"),

   385

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

   386

        self.AddProjectDefaultConfiguration()

   387

   388

        # Change XSD into class members

   389

        self._AddParamsMembers()

   390

        self.Children = {}

   391

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

   392

        self.ProjectPath = ProjectPath

   393

        self._setBuildPath(BuildPath)

   394

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

   395

        self.RefreshConfNodesBlockLists()

   396

        # this will create files base XML files

   397

        self.SaveProject()

   398

        return None

   399

   400

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

   401

        """

   402

        Load a project contained in a folder

   403

        @param ProjectPath: path of the project folder

   404

        """

   405

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

   406

            ProjectPath = os.path.dirname(ProjectPath)

   407

        # Verify that project contains a PLCOpen program

   408

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

   409

        if not os.path.isfile(plc_file):

   410

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

   411

        # Load PLCOpen file

   412

        error = self.OpenXMLFile(plc_file)

   413

        if error is not None:

   414

            if self.Project is not None:

   415

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

   416

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

   417

            else:

   418

                return error, False

   419

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

   420

            self.AddProjectDefaultConfiguration()

   421

        # Change XSD into class members

   422

        self._AddParamsMembers()

   423

        self.Children = {}

   424

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

   425

        self.ProjectPath = ProjectPath

   426

        self._setBuildPath(BuildPath)

   427

        # If dir have already be made, and file exist

   428

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

   429

            #Load the confnode.xml file into parameters members

   430

            result = self.LoadXMLParams()

   431

            if result:

   432

                return result, False

   433

            #Load and init all the children

   434

            self.LoadChildren()

   435

        self.RefreshConfNodesBlockLists()

   436

        self.UpdateButtons()

   437

        return None, False

   438

   439

    def RecursiveConfNodeInfos(self, confnode):

   440

        values = []

   441

        for CTNChild in confnode.IECSortedChildren():

   442

            values.append(

   443

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

   444

                                     CTNChild.CTNName()),

   445

                 "tagname": CTNChild.CTNFullName(),

   446

                 "type": ITEM_CONFNODE,

   447

                 "confnode": CTNChild,

   448

                 "icon": CTNChild.GetIconName(),

   449

                 "values": self.RecursiveConfNodeInfos(CTNChild)})

   450

        return values

   451

   452

    def GetProjectInfos(self):

   453

        infos = PLCControler.GetProjectInfos(self)

   454

        configurations = infos["values"].pop(-1)

   455

        resources = None

   456

        for config_infos in configurations["values"]:

   457

            if resources is None:

   458

                resources = config_infos["values"][0]

   459

            else:

   460

                resources["values"].extend(config_infos["values"][0]["values"])

   461

        if resources is not None:

   462

            infos["values"].append(resources)

   463

        infos["values"].extend(self.RecursiveConfNodeInfos(self))

   464

        return infos

   465

   466

    def CloseProject(self):

   467

        self.ClearChildren()

   468

        self.ResetAppFrame(None)

   469

   470

    def CheckNewProjectPath(self, old_project_path, new_project_path):

   471

        if old_project_path == new_project_path:

   472

            message = (_("Save path is the same as path of a project! \n"))

   473

            dialog = wx.MessageDialog(self.AppFrame, message, _("Error"), wx.OK | wx.ICON_ERROR)

   474

            dialog.ShowModal()

   475

            return False

   476

        else:

   477

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

   478

            if os.path.isfile(plc_file):

   479

                message = (_("Selected directory already contains another project. Overwrite? \n"))

   480

                dialog = wx.MessageDialog(self.AppFrame, message, _("Error"), wx.YES_NO | wx.ICON_ERROR)

   481

                answer = dialog.ShowModal()

   482

                return answer == wx.ID_YES