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

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

   364

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

   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

        self.UpdateButtons()

   385

        return None

   386

   387

    def RecursiveConfNodeInfos(self, confnode):

   388

        values = []

   389

        for CTNChild in confnode.IECSortedChildren():

   390

            values.append(

   391

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

   392

                                     CTNChild.CTNName()),

   393

                 "tagname": CTNChild.CTNFullName(),

   394

                 "type": ITEM_CONFNODE,

   395

                 "confnode": CTNChild,

   396

                 "icon": CTNChild.GetIconName(),

   397

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

   398

        return values

   399

   400

    def GetProjectInfos(self):

   401

        infos = PLCControler.GetProjectInfos(self)

   402

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

   403

        resources = None

   404

        for config_infos in configurations["values"]:

   405

            if resources is None:

   406

                resources = config_infos["values"][0]

   407

            else:

   408

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

   409

        if resources is not None:

   410

            infos["values"].append(resources)

   411

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

   412

        return infos

   413

   414

    def CloseProject(self):

   415

        self.ClearChildren()

   416

        self.ResetAppFrame(None)

   417

   418

    def SaveProject(self, from_project_path=None):

   419

        if self.CheckProjectPathPerm(False):

   420

            if from_project_path is not None:

   421

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   422

                if os.path.isdir(old_projectfiles_path):

   423

                    shutil.copytree(old_projectfiles_path,

   424

                                    self._getProjectFilesPath(self.ProjectPath))

   425

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

   426

            result = self.CTNRequestSave(from_project_path)

   427

            if result:

   428

                self.logger.write_error(result)

   429

   430

    def SaveProjectAs(self):

   431

        # Ask user to choose a path with write permissions

   432

        if wx.Platform == '__WXMSW__':

   433

            path = os.getenv("USERPROFILE")

   434

        else:

   435

            path = os.getenv("HOME")

   436

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

   437

        answer = dirdialog.ShowModal()

   438

        dirdialog.Destroy()

   439

        if answer == wx.ID_OK:

   440

            newprojectpath = dirdialog.GetPath()

   441

            if os.path.isdir(newprojectpath):

   442

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   443

                self.SaveProject(old_project_path)

   444

                self._setBuildPath(self.BuildPath)

   445

                return True

   446

        return False

   447

   448

    def GetLibrariesTypes(self):

   449

        self.LoadLibraries()

   450

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

   451

   452

    def GetLibrariesSTCode(self):

   453

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

   454

   455

    def GetLibrariesCCode(self, buildpath):

   456

        if len(self.Libraries)==0:

   457

            return [],[],()

   458

        self.GetIECProgramsAndVariables()

   459

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

   460

        LocatedCCodeAndFlags=[]

   461

        Extras=[]

   462

        for lib in self.Libraries:

   463

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

   464

            LocatedCCodeAndFlags.append(res[:2])

   465

            if len(res)>2:

   466

                Extras.extend(res[2:])

   467

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

   468

   469

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   470

    def RefreshConfNodesBlockLists(self):

   471

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

   472

            self.ClearConfNodeTypes()

   473

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   474

        if self.AppFrame is not None:

   475

            self.AppFrame.RefreshLibraryPanel()

   476

            self.AppFrame.RefreshEditor()

   477

   478

    # Update a PLCOpenEditor Pou variable location

   479

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   480

        self.Project.updateElementAddress(old_leading, new_leading)