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

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

"""

    26

Beremiz Project Controller

    27

"""

    28

import os,sys,traceback

    29

import time

    30

import features

    31

import shutil

    32

import wx

    33

import re, tempfile

    34

from math import ceil

    35

from types import ListType

    36

from threading import Timer, Lock, Thread

    37

from time import localtime

    38

from datetime import datetime

    39

from weakref import WeakKeyDictionary

    40

from itertools import izip

    41

    42

import targets

    43

import connectors

    44

from util.misc import CheckPathPerm, GetClassImporter

    45

from util.MiniTextControler import MiniTextControler

    46

from util.ProcessLogger import ProcessLogger

    47

from util.BitmapLibrary import GetBitmap

    48

from editors.FileManagementPanel import FileManagementPanel

    49

from editors.ProjectNodeEditor import ProjectNodeEditor

    50

from editors.IECCodeViewer import IECCodeViewer

    51

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    52

from dialogs import DiscoveryDialog

    53

from PLCControler import PLCControler

    54

from plcopen.structures import IEC_KEYWORDS

    55

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    56

from targets.typemapping import UnpackDebugBuffer

    57

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    58

    59

base_folder = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]

    60

    61

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

    62

    63

ITEM_CONFNODE = 25

    64

    65

def ExtractChildrenTypesFromCatalog(catalog):

    66

    children_types = []

    67

    for n,d,h,c in catalog:

    68

        if isinstance(c, ListType):

    69

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    70

        else:

    71

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

    72

    return children_types

    73

    74

def ExtractMenuItemsFromCatalog(catalog):

    75

    menu_items = []

    76

    for n,d,h,c in catalog:

    77

        if isinstance(c, ListType):

    78

            children = ExtractMenuItemsFromCatalog(c)

    79

        else:

    80

            children = []

    81

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

    82

    return menu_items

    83

    84

def GetAddMenuItems():

    85

    return ExtractMenuItemsFromCatalog(features.catalog)

    86

    87

class ProjectController(ConfigTreeNode, PLCControler):

    88

    """

    89

    This class define Root object of the confnode tree.

    90

    It is responsible of :

    91

    - Managing project directory

    92

    - Building project

    93

    - Handling PLCOpenEditor controler and view

    94

    - Loading user confnodes and instanciante them as children

    95

    - ...

    96

    97

    """

    98

    99

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

   100

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   101

   102

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

   103

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

   104

      <xsd:element name="BeremizRoot">

   105

        <xsd:complexType>

   106

          <xsd:sequence>

   107

            <xsd:element name="TargetType">

   108

              <xsd:complexType>

   109

                <xsd:choice minOccurs="0">

   110

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

   111

                </xsd:choice>

   112

              </xsd:complexType>

   113

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

   114

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

   115

              <xsd:complexType>

   116

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

   117

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

   118

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

   119

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

   120

              </xsd:complexType>

   121

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

   122

          </xsd:sequence>

   123

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

   124

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

   125

        </xsd:complexType>

   126

      </xsd:element>

   127

    </xsd:schema>

   128

    """

   129

    EditorType = ProjectNodeEditor

   130

   131

    def __init__(self, frame, logger):

   132

        PLCControler.__init__(self)

   133

   134

        self.MandatoryParams = None

   135

        self._builder = None

   136

        self._connector = None

   137

        self.DispatchDebugValuesTimer = None

   138

        self.DebugValuesBuffers = []

   139

        self.DebugTicks = []

   140

        self.SetAppFrame(frame, logger)

   141

   142

        self.iec2c_path = os.path.join(base_folder, "matiec", "iec2c"+(".exe" if wx.Platform == '__WXMSW__' else ""))

   143

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

   144

        self.ieclib_c_path = self._getMatIecCPath()

   145

   146

        # Setup debug information

   147

        self.IECdebug_datas = {}

   148

        self.IECdebug_lock = Lock()

   149

   150

        self.DebugTimer=None

   151

        self.ResetIECProgramsAndVariables()

   152

   153

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

   154

        self.ChangesToSave = False

   155

        # root have no parent

   156

        self.CTNParent = None

   157

        # Keep track of the confnode type name

   158

        self.CTNType = "Beremiz"

   159

        self.Children = {}

   160

        self._View = None

   161

        # After __init__ root confnode is not valid

   162

        self.ProjectPath = None

   163

        self._setBuildPath(None)

   164

        self.DebugThread = None

   165

        self.debug_break = False

   166

        self.previous_plcstate = None

   167

        # copy ConfNodeMethods so that it can be later customized

   168

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

   169

   170

    def __del__(self):

   171

        if self.DebugTimer:

   172

            self.DebugTimer.cancel()

   173

        self.KillDebugThread()

   174

   175

    def LoadLibraries(self):

   176

        self.Libraries = []

   177

        TypeStack=[]

   178

        for libname,clsname in features.libraries:

   179

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

   180

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

   181

                TypeStack.append(Lib.GetTypes())

   182

                self.Libraries.append(Lib)

   183

   184

    def SetAppFrame(self, frame, logger):

   185

        self.AppFrame = frame

   186

        self.logger = logger

   187

        self.StatusTimer = None

   188

        if self.DispatchDebugValuesTimer is not None:

   189

            self.DispatchDebugValuesTimer.Stop()

   190

        self.DispatchDebugValuesTimer = None

   191

   192

        if frame is not None:

   193

   194

            # Timer to pull PLC status

   195

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

   196

            self.AppFrame.Bind(wx.EVT_TIMER,

   197

                self.PullPLCStatusProc, self.StatusTimer)

   198

   199

            if self._connector is not None:

   200

                frame.LogViewer.SetLogSource(self._connector)

   201

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

   202

   203

            # Timer to dispatch debug values to consumers

   204

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

   205

            self.AppFrame.Bind(wx.EVT_TIMER,

   206

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   207

   208

            self.RefreshConfNodesBlockLists()

   209

   210

    def ResetAppFrame(self, logger):

   211

        if self.AppFrame is not None:

   212

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

   213

            self.StatusTimer = None

   214

            self.AppFrame = None

   215

   216

        self.logger = logger

   217

   218

    def CTNName(self):

   219

        return "Project"

   220

   221

    def CTNTestModified(self):

   222

         return self.ChangesToSave or not self.ProjectIsSaved()

   223

   224

    def CTNFullName(self):

   225

        return ""

   226

   227

    def GetCTRoot(self):

   228

        return self

   229

   230

    def GetIECLibPath(self):

   231

        return self.ieclib_c_path

   232

   233

    def GetIEC2cPath(self):

   234

        return self.iec2c_path

   235

   236

    def GetCurrentLocation(self):

   237

        return ()

   238

   239

    def GetCurrentName(self):

   240

        return ""

   241

   242

    def _GetCurrentName(self):

   243

        return ""

   244

   245

    def GetProjectPath(self):

   246

        return self.ProjectPath

   247

   248

    def GetProjectName(self):

   249

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

   250

   251

    def GetIconName(self):

   252

        return "PROJECT"

   253

   254

    def GetDefaultTargetName(self):

   255

        if wx.Platform == '__WXMSW__':

   256

            return "Win32"

   257

        else:

   258

            return "Linux"

   259

   260

    def GetTarget(self):

   261

        target = self.BeremizRoot.getTargetType()

   262

        if target.getcontent() is None:

   263

            temp_root = self.Parser.CreateRoot()

   264

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

   265

            temp_root.setTargetType(target)

   266

            target_name = self.GetDefaultTargetName()

   267

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

   268

        return target

   269

   270

    def GetParamsAttributes(self, path = None):

   271

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   272

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

   273

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

   274

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

   275

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

   276

        return params

   277

   278

    def SetParamsAttribute(self, path, value):

   279

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

   280

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

   281

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

   282

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

   283

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   284

        return res

   285

   286

    # helper func to check project path write permission

   287

    def CheckProjectPathPerm(self, dosave=True):

   288

        if CheckPathPerm(self.ProjectPath):

   289

            return True

   290

        if self.AppFrame is not None:

   291

            dialog = wx.MessageDialog(self.AppFrame,

   292

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

   293

                        _('Error'),

   294

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

   295

            answer = dialog.ShowModal()

   296

            dialog.Destroy()

   297

            if answer == wx.ID_YES:

   298

                if self.SaveProjectAs():

   299

                    self.AppFrame.RefreshTitle()

   300

                    self.AppFrame.RefreshFileMenu()

   301

                    self.AppFrame.RefreshPageTitles()

   302

                    return True

   303

        return False

   304

   305

    def _getProjectFilesPath(self, project_path=None):

   306

        if project_path is not None:

   307

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

   308

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

   309

        if not os.path.exists(projectfiles_path):

   310

            os.mkdir(projectfiles_path)

   311

        return projectfiles_path

   312

   313

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

   314

        self.ProjectAddConfiguration(config_name)

   315

        self.ProjectAddConfigurationResource(config_name, res_name)

   316

   317

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

   318

        """

   319

        Create a new project in an empty folder

   320

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

   321

        @param PLCParams: properties of the PLCOpen program created

   322

        """

   323

        # Verify that chosen folder is empty

   324

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

   325

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

   326

   327

        # Create PLCOpen program

   328

        self.CreateNewProject(

   329

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

   330

             "productName": _("Unnamed"),

   331

             "productVersion": "1",

   332

             "companyName": _("Unknown"),

   333

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

   334

        self.AddProjectDefaultConfiguration()

   335

   336

        # Change XSD into class members

   337

        self._AddParamsMembers()

   338

        self.Children = {}

   339

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

   340

        self.ProjectPath = ProjectPath

   341

        self._setBuildPath(BuildPath)

   342

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

   343

        self.RefreshConfNodesBlockLists()

   344

        # this will create files base XML files

   345

        self.SaveProject()

   346

        return None

   347

   348

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

   349

        """

   350

        Load a project contained in a folder

   351

        @param ProjectPath: path of the project folder

   352

        """

   353

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

   354

            ProjectPath = os.path.dirname(ProjectPath)

   355

        # Verify that project contains a PLCOpen program

   356

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

   357

        if not os.path.isfile(plc_file):

   358

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

   359

        # Load PLCOpen file

   360

        error = self.OpenXMLFile(plc_file)

   361

        if error is not None:

   362

            if self.Project is not None:

   363

                self.logger.write_warning(

   364

                    XSDSchemaErrorMessage % (("PLC",) + error))

   365

            else:

   366

                return error

   367

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

   368

            self.AddProjectDefaultConfiguration()

   369

        # Change XSD into class members

   370

        self._AddParamsMembers()

   371

        self.Children = {}

   372

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

   373

        self.ProjectPath = ProjectPath

   374

        self._setBuildPath(BuildPath)

   375

        # If dir have already be made, and file exist

   376

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

   377

            #Load the confnode.xml file into parameters members

   378

            result = self.LoadXMLParams()

   379

            if result:

   380

                return result

   381

            #Load and init all the children

   382

            self.LoadChildren()

   383

        self.RefreshConfNodesBlockLists()

   384

   385

        if os.path.exists(self._getBuildPath()):

   386

            self.EnableMethod("_Clean", True)

   387

   388

        if os.path.isfile(self._getIECcodepath()):

   389

            self.ShowMethod("_showIECcode", True)

   390

   391

        self.UpdateMethodsFromPLCStatus()

   392

   393

        return None

   394

   395

    def RecursiveConfNodeInfos(self, confnode):

   396

        values = []

   397

        for CTNChild in confnode.IECSortedChildren():

   398

            values.append(

   399

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

   400

                                     CTNChild.CTNName()),

   401

                 "tagname": CTNChild.CTNFullName(),

   402

                 "type": ITEM_CONFNODE,

   403

                 "confnode": CTNChild,

   404

                 "icon": CTNChild.GetIconName(),

   405

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

   406

        return values

   407

   408

    def GetProjectInfos(self):

   409

        infos = PLCControler.GetProjectInfos(self)

   410

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

   411

        resources = None

   412

        for config_infos in configurations["values"]:

   413

            if resources is None:

   414

                resources = config_infos["values"][0]

   415

            else:

   416

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

   417

        if resources is not None:

   418

            infos["values"].append(resources)

   419

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

   420

        return infos

   421

   422

    def CloseProject(self):

   423

        self.ClearChildren()

   424

        self.ResetAppFrame(None)

   425

   426

    def SaveProject(self, from_project_path=None):

   427

        if self.CheckProjectPathPerm(False):

   428

            if from_project_path is not None:

   429

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   430

                if os.path.isdir(old_projectfiles_path):

   431

                    shutil.copytree(old_projectfiles_path,

   432

                                    self._getProjectFilesPath(self.ProjectPath))

   433

            self.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))

   434

            result = self.CTNRequestSave(from_project_path)

   435

            if result:

   436

                self.logger.write_error(result)

   437

   438

    def SaveProjectAs(self):

   439

        # Ask user to choose a path with write permissions

   440

        if wx.Platform == '__WXMSW__':

   441

            path = os.getenv("USERPROFILE")

   442

        else:

   443

            path = os.getenv("HOME")

   444

        dirdialog = wx.DirDialog(self.AppFrame , _("Choose a directory to save project"), path, wx.DD_NEW_DIR_BUTTON)

   445

        answer = dirdialog.ShowModal()

   446

        dirdialog.Destroy()

   447

        if answer == wx.ID_OK:

   448

            newprojectpath = dirdialog.GetPath()

   449

            if os.path.isdir(newprojectpath):

   450

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   451

                self.SaveProject(old_project_path)

   452

                self._setBuildPath(self.BuildPath)

   453

                return True

   454

        return False

   455

   456

    def GetLibrariesTypes(self):

   457

        self.LoadLibraries()

   458

        return [ lib.GetTypes() for lib in self.Libraries ]

   459

   460

    def GetLibrariesSTCode(self):

   461

        return "\n".join([ lib.GetSTCode() for lib in self.Libraries ])

   462

   463

    def GetLibrariesCCode(self, buildpath):

   464

        if len(self.Libraries)==0:

   465

            return [],[],()

   466

        self.GetIECProgramsAndVariables()

   467

        LibIECCflags = '"-I%s" -Wno-unused-function'%os.path.abspath(self.GetIECLibPath())

   468

        LocatedCCodeAndFlags=[]

   469

        Extras=[]

   470

        for lib in self.Libraries:

   471

            res=lib.Generate_C(buildpath,self._VariablesList,LibIECCflags)

   472

            LocatedCCodeAndFlags.append(res[:2])

   473

            if len(res)>2:

   474

                Extras.extend(res[2:])

   475

        return map(list,zip(*LocatedCCodeAndFlags))+[tuple(Extras)]

   476

   477

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   478

    def RefreshConfNodesBlockLists(self):

   479

        if getattr(self, "Children", None) is not None:

   480

            self.ClearConfNodeTypes()

   481