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 Iec2CSettings():

    88

    def __init__(self):

    89

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

    90

        self.iec2c_buildopts = None

    91

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

    92

        self.ieclib_c_path = None

    93

    94

    def findLibCPath(self):

    95

        path=""

    96

        paths=[

    97

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

    98

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

    99

        for p in paths:

   100

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

   101

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

   102

                path = p

   103

                break

   104

        return path

   105

   106

    def findSupportedOptions(self):

   107

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

   108

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

   109

   110

        buildopt = ""

   111

        try:

   112

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

   113

            status, result, err_result = ProcessLogger(self.logger, buildcmd,

   114

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

   115

        except Exception,e:

   116

            return buildopt

   117

   118

        for opt in options:

   119

            if opt in result:

   120

                buildopt = buildopt + " " + opt

   121

        return buildopt

   122

   123

    def getCmd(self):

   124

        return self.iec2c

   125

   126

    def getOptions(self):

   127

        if self.iec2c_buildopts is None:

   128

            self.iec2c_buildopts = self.findSupportedOptions()

   129

        return self.iec2c_buildopts

   130

   131

    def getLibPath(self):

   132

        return self.ieclib_path

   133

   134

    def getLibCPath(self):

   135

        if self.ieclib_c_path is None:

   136

            self.ieclib_c_path = self.findLibCPath()

   137

        return self.ieclib_c_path

   138

   139

iec2c_cfg = Iec2CSettings()

   140

   141

class ProjectController(ConfigTreeNode, PLCControler):

   142

    """

   143

    This class define Root object of the confnode tree.

   144

    It is responsible of :

   145

    - Managing project directory

   146

    - Building project

   147

    - Handling PLCOpenEditor controler and view

   148

    - Loading user confnodes and instanciante them as children

   149

    - ...

   150

   151

    """

   152

   153

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

   154

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   155

   156

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

   157

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

   158

      <xsd:element name="BeremizRoot">

   159

        <xsd:complexType>

   160

          <xsd:sequence>

   161

            <xsd:element name="TargetType">

   162

              <xsd:complexType>

   163

                <xsd:choice minOccurs="0">

   164

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

   165

                </xsd:choice>

   166

              </xsd:complexType>

   167

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

   168

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

   169

              <xsd:complexType>

   170

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

   171

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

   172

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

   173

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

   174

              </xsd:complexType>

   175

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

   176

          </xsd:sequence>

   177

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

   178

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

   179

        </xsd:complexType>

   180

      </xsd:element>

   181

    </xsd:schema>

   182

    """

   183

    EditorType = ProjectNodeEditor

   184

   185

    def __init__(self, frame, logger):

   186

        PLCControler.__init__(self)

   187

   188

        self.MandatoryParams = None

   189

        self._builder = None

   190

        self._connector = None

   191

        self.DispatchDebugValuesTimer = None

   192

        self.DebugValuesBuffers = []

   193

        self.DebugTicks = []

   194

        self.SetAppFrame(frame, logger)

   195

   196

        # Setup debug information

   197

        self.IECdebug_datas = {}

   198

        self.IECdebug_lock = Lock()

   199

   200

        self.DebugTimer=None

   201

        self.ResetIECProgramsAndVariables()

   202

   203

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

   204

        self.ChangesToSave = False

   205

        # root have no parent

   206

        self.CTNParent = None

   207

        # Keep track of the confnode type name

   208

        self.CTNType = "Beremiz"

   209

        self.Children = {}

   210

        self._View = None

   211

        # After __init__ root confnode is not valid

   212

        self.ProjectPath = None

   213

        self._setBuildPath(None)

   214

        self.DebugThread = None

   215

        self.debug_break = False

   216

        self.previous_plcstate = None

   217

        # copy ConfNodeMethods so that it can be later customized

   218

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

   219

   220

    def __del__(self):

   221

        if self.DebugTimer:

   222

            self.DebugTimer.cancel()

   223

        self.KillDebugThread()

   224

   225

    def LoadLibraries(self):

   226

        self.Libraries = []

   227

        TypeStack=[]

   228

        for libname,clsname in features.libraries:

   229

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

   230

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

   231

                TypeStack.append(Lib.GetTypes())

   232

                self.Libraries.append(Lib)

   233

   234

    def SetAppFrame(self, frame, logger):

   235

        self.AppFrame = frame

   236

        self.logger = logger

   237

        self.StatusTimer = None

   238

        if self.DispatchDebugValuesTimer is not None:

   239

            self.DispatchDebugValuesTimer.Stop()

   240

        self.DispatchDebugValuesTimer = None

   241

   242

        if frame is not None:

   243

   244

            # Timer to pull PLC status

   245

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

   246

            self.AppFrame.Bind(wx.EVT_TIMER,

   247

                self.PullPLCStatusProc, self.StatusTimer)

   248

   249

            if self._connector is not None:

   250

                frame.LogViewer.SetLogSource(self._connector)

   251

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

   252

   253

            # Timer to dispatch debug values to consumers

   254

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

   255

            self.AppFrame.Bind(wx.EVT_TIMER,

   256

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   257

   258

            self.RefreshConfNodesBlockLists()

   259

   260

    def ResetAppFrame(self, logger):

   261

        if self.AppFrame is not None:

   262

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

   263

            self.StatusTimer = None

   264

            self.AppFrame = None

   265

   266

        self.logger = logger

   267

   268

    def CTNName(self):

   269

        return "Project"

   270

   271

    def CTNTestModified(self):

   272

         return self.ChangesToSave or not self.ProjectIsSaved()

   273

   274

    def CTNFullName(self):

   275

        return ""

   276

   277

    def GetCTRoot(self):

   278

        return self

   279

   280

    def GetIECLibPath(self):

   281

        return iec2c_cfg.getLibCPath()

   282

   283

    def GetIEC2cPath(self):

   284

        return iec2c_cfg.getCmd()

   285

   286

    def GetCurrentLocation(self):

   287

        return ()

   288

   289

    def GetCurrentName(self):

   290

        return ""

   291

   292

    def _GetCurrentName(self):

   293

        return ""

   294

   295

    def GetProjectPath(self):

   296

        return self.ProjectPath

   297

   298

    def GetProjectName(self):

   299

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

   300

   301

    def GetIconName(self):

   302

        return "PROJECT"

   303

   304

    def GetDefaultTargetName(self):

   305

        if wx.Platform == '__WXMSW__':

   306

            return "Win32"

   307

        else:

   308

            return "Linux"

   309

   310

    def GetTarget(self):

   311

        target = self.BeremizRoot.getTargetType()

   312

        if target.getcontent() is None:

   313

            temp_root = self.Parser.CreateRoot()

   314

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

   315

            temp_root.setTargetType(target)

   316

            target_name = self.GetDefaultTargetName()

   317

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

   318

        return target

   319

   320

    def GetParamsAttributes(self, path = None):

   321

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   322

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

   323

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

   324

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

   325

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

   326

        return params

   327

   328

    def SetParamsAttribute(self, path, value):

   329

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

   330

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

   331

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

   332

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

   333

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   334

        return res

   335

   336

    # helper func to check project path write permission

   337

    def CheckProjectPathPerm(self, dosave=True):

   338

        if CheckPathPerm(self.ProjectPath):

   339

            return True

   340

        if self.AppFrame is not None:

   341

            dialog = wx.MessageDialog(self.AppFrame,

   342

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

   343

                        _('Error'),

   344

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

   345

            answer = dialog.ShowModal()

   346

            dialog.Destroy()

   347

            if answer == wx.ID_YES:

   348

                if self.SaveProjectAs():

   349

                    self.AppFrame.RefreshTitle()

   350

                    self.AppFrame.RefreshFileMenu()

   351

                    self.AppFrame.RefreshPageTitles()

   352

                    return True

   353

        return False

   354

   355

    def _getProjectFilesPath(self, project_path=None):

   356

        if project_path is not None:

   357

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

   358

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

   359

        if not os.path.exists(projectfiles_path):

   360

            os.mkdir(projectfiles_path)

   361

        return projectfiles_path

   362

   363

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

   364

        self.ProjectAddConfiguration(config_name)

   365

        self.ProjectAddConfigurationResource(config_name, res_name)

   366

   367

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

   368

        """

   369

        Create a new project in an empty folder

   370

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

   371

        @param PLCParams: properties of the PLCOpen program created

   372

        """

   373

        # Verify that chosen folder is empty

   374

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

   375

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

   376

   377

        # Create PLCOpen program

   378

        self.CreateNewProject(

   379

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

   380

             "productName": _("Unnamed"),

   381

             "productVersion": "1",

   382

             "companyName": _("Unknown"),

   383

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

   384

        self.AddProjectDefaultConfiguration()

   385

   386

        # Change XSD into class members

   387

        self._AddParamsMembers()

   388

        self.Children = {}

   389

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

   390

        self.ProjectPath = ProjectPath

   391

        self._setBuildPath(BuildPath)

   392

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

   393

        self.RefreshConfNodesBlockLists()

   394

        # this will create files base XML files

   395

        self.SaveProject()

   396

        return None

   397

   398

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

   399

        """

   400

        Load a project contained in a folder

   401

        @param ProjectPath: path of the project folder

   402

        """

   403

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

   404

            ProjectPath = os.path.dirname(ProjectPath)

   405

        # Verify that project contains a PLCOpen program

   406

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

   407

        if not os.path.isfile(plc_file):

   408

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

   409

        # Load PLCOpen file

   410

        error = self.OpenXMLFile(plc_file)

   411

        if error is not None:

   412

            if self.Project is not None:

   413

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

   414

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

   415

            else:

   416

                return error, False

   417

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

   418

            self.AddProjectDefaultConfiguration()

   419

        # Change XSD into class members

   420

        self._AddParamsMembers()

   421

        self.Children = {}

   422

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

   423

        self.ProjectPath = ProjectPath

   424

        self._setBuildPath(BuildPath)

   425

        # If dir have already be made, and file exist

   426

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

   427

            #Load the confnode.xml file into parameters members

   428

            result = self.LoadXMLParams()

   429

            if result:

   430

                return result, False

   431

            #Load and init all the children

   432

            self.LoadChildren()

   433

        self.RefreshConfNodesBlockLists()

   434

        self.UpdateButtons()

   435

        return None, False

   436

   437

    def RecursiveConfNodeInfos(self, confnode):

   438

        values = []

   439

        for CTNChild in confnode.IECSortedChildren():

   440

            values.append(

   441

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

   442

                                     CTNChild.CTNName()),

   443

                 "tagname": CTNChild.CTNFullName(),

   444

                 "type": ITEM_CONFNODE,

   445

                 "confnode": CTNChild,

   446

                 "icon": CTNChild.GetIconName(),

   447

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

   448

        return values

   449

   450

    def GetProjectInfos(self):

   451

        infos = PLCControler.GetProjectInfos(self)

   452

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

   453

        resources = None

   454

        for config_infos in configurations["values"]:

   455

            if resources is None:

   456

                resources = config_infos["values"][0]

   457

            else:

   458

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

   459

        if resources is not None:

   460

            infos["values"].append(resources)

   461

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

   462

        return infos

   463

   464

    def CloseProject(self):

   465

        self.ClearChildren()

   466

        self.ResetAppFrame(None)

   467

   468

    def CheckNewProjectPath(self, old_project_path, new_project_path):

   469

        if old_project_path == new_project_path:

   470

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

   471

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

   472

            dialog.ShowModal()

   473

            return False

   474

        else:

   475

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

   476

            if os.path.isfile(plc_file):

   477

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

   478

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

   479

                answer = dialog.ShowModal()

   480

                return answer == wx.ID_YES

   481

        return True

   482