1

"""

     2

Beremiz Project Controller

     3

"""

     4

import os,sys,traceback

     5

import time

     6

import features

     7

import shutil

     8

import wx

     9

import re, tempfile

    10

from math import ceil

    11

from types import ListType

    12

from threading import Timer, Lock, Thread

    13

from time import localtime

    14

from datetime import datetime

    15

from weakref import WeakKeyDictionary

    16

    17

import targets

    18

import connectors

    19

from util.misc import CheckPathPerm, GetClassImporter

    20

from util.MiniTextControler import MiniTextControler

    21

from util.ProcessLogger import ProcessLogger

    22

from util.BitmapLibrary import GetBitmap

    23

from editors.FileManagementPanel import FileManagementPanel

    24

from editors.ProjectNodeEditor import ProjectNodeEditor

    25

from editors.IECCodeViewer import IECCodeViewer

    26

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    27

from dialogs import DiscoveryDialog

    28

from PLCControler import PLCControler

    29

from plcopen.structures import IEC_KEYWORDS

    30

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    31

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    32

    33

base_folder = os.path.split(sys.path[0])[0]

    34

    35

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

    36

    37

DEBUG_RETRIES_WARN = 3

    38

DEBUG_RETRIES_REREGISTER = 4

    39

    40

ITEM_CONFNODE = 25

    41

    42

def ExtractChildrenTypesFromCatalog(catalog):

    43

    children_types = []

    44

    for n,d,h,c in catalog:

    45

        if isinstance(c, ListType):

    46

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    47

        else:

    48

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

    49

    return children_types

    50

    51

def ExtractMenuItemsFromCatalog(catalog):

    52

    menu_items = []

    53

    for n,d,h,c in catalog:

    54

        if isinstance(c, ListType):

    55

            children = ExtractMenuItemsFromCatalog(c)

    56

        else:

    57

            children = []

    58

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

    59

    return menu_items

    60

    61

def GetAddMenuItems():

    62

    return ExtractMenuItemsFromCatalog(features.catalog)

    63

    64

class ProjectController(ConfigTreeNode, PLCControler):

    65

    """

    66

    This class define Root object of the confnode tree.

    67

    It is responsible of :

    68

    - Managing project directory

    69

    - Building project

    70

    - Handling PLCOpenEditor controler and view

    71

    - Loading user confnodes and instanciante them as children

    72

    - ...

    73

    74

    """

    75

    76

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

    77

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

    78

    79

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

    80

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

    81

      <xsd:element name="BeremizRoot">

    82

        <xsd:complexType>

    83

          <xsd:sequence>

    84

            <xsd:element name="TargetType">

    85

              <xsd:complexType>

    86

                <xsd:choice minOccurs="0">

    87

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

    88

                </xsd:choice>

    89

              </xsd:complexType>

    90

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

    91

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

    92

              <xsd:complexType>

    93

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

    94

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

    95

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

    96

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

    97

              </xsd:complexType>

    98

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

    99

          </xsd:sequence>

   100

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

   101

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

   102

        </xsd:complexType>

   103

      </xsd:element>

   104

    </xsd:schema>

   105

    """

   106

    EditorType = ProjectNodeEditor

   107

   108

    def __init__(self, frame, logger):

   109

        PLCControler.__init__(self)

   110

   111

        self.MandatoryParams = None

   112

        self._builder = None

   113

        self._connector = None

   114

        self.DispatchDebugValuesTimer = None

   115

        self.DebugValuesBuffers = []

   116

        self.DebugTicks = []

   117

        self.SetAppFrame(frame, logger)

   118

   119

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

   120

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

   121

   122

        # Setup debug information

   123

        self.IECdebug_datas = {}

   124

        self.IECdebug_lock = Lock()

   125

   126

        self.DebugTimer=None

   127

        self.ResetIECProgramsAndVariables()

   128

   129

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

   130

        self.ChangesToSave = False

   131

        # root have no parent

   132

        self.CTNParent = None

   133

        # Keep track of the confnode type name

   134

        self.CTNType = "Beremiz"

   135

        self.Children = {}

   136

        self._View = None

   137

        # After __init__ root confnode is not valid

   138

        self.ProjectPath = None

   139

        self._setBuildPath(None)

   140

        self.DebugThread = None

   141

        self.debug_break = False

   142

        self.previous_plcstate = None

   143

        # copy ConfNodeMethods so that it can be later customized

   144

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

   145

   146

    def __del__(self):

   147

        if self.DebugTimer:

   148

            self.DebugTimer.cancel()

   149

        self.KillDebugThread()

   150

   151

    def LoadLibraries(self):

   152

        self.Libraries = []

   153

        TypeStack=[]

   154

        for libname,clsname in features.libraries:

   155

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

   156

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

   157

                TypeStack.append(Lib.GetTypes())

   158

                self.Libraries.append(Lib)

   159

   160

    def SetAppFrame(self, frame, logger):

   161

        self.AppFrame = frame

   162

        self.logger = logger

   163

        self.StatusTimer = None

   164

        if self.DispatchDebugValuesTimer is not None:

   165

            self.DispatchDebugValuesTimer.Stop()

   166

        self.DispatchDebugValuesTimer = None

   167

   168

        if frame is not None:

   169

   170

            # Timer to pull PLC status

   171

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

   172

            self.AppFrame.Bind(wx.EVT_TIMER,

   173

                self.PullPLCStatusProc, self.StatusTimer)

   174

   175

            if self._connector is not None:

   176

                frame.LogViewer.SetLogSource(self._connector)

   177

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

   178

   179

            # Timer to dispatch debug values to consumers

   180

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

   181

            self.AppFrame.Bind(wx.EVT_TIMER,

   182

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   183

   184

            self.RefreshConfNodesBlockLists()

   185

   186

    def ResetAppFrame(self, logger):

   187

        if self.AppFrame is not None:

   188

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

   189

            self.StatusTimer = None

   190

            self.AppFrame = None

   191

   192

        self.logger = logger

   193

   194

    def CTNName(self):

   195

        return "Project"

   196

   197

    def CTNTestModified(self):

   198

         return self.ChangesToSave or not self.ProjectIsSaved()

   199

   200

    def CTNFullName(self):

   201

        return ""

   202

   203

    def GetCTRoot(self):

   204

        return self

   205

   206

    def GetIECLibPath(self):

   207

        return self.ieclib_path

   208

   209

    def GetIEC2cPath(self):

   210

        return self.iec2c_path

   211

   212

    def GetCurrentLocation(self):

   213

        return ()

   214

   215

    def GetCurrentName(self):

   216

        return ""

   217

   218

    def _GetCurrentName(self):

   219

        return ""

   220

   221

    def GetProjectPath(self):

   222

        return self.ProjectPath

   223

   224

    def GetProjectName(self):

   225

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

   226

   227

    def GetIconName(self):

   228

        return "PROJECT"

   229

   230

    def GetDefaultTargetName(self):

   231

        if wx.Platform == '__WXMSW__':

   232

            return "Win32"

   233

        else:

   234

            return "Linux"

   235

   236

    def GetTarget(self):

   237

        target = self.BeremizRoot.getTargetType()

   238

        if target.getcontent() is None:

   239

            temp_root = self.Parser.CreateRoot()

   240

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

   241

            temp_root.setTargetType(target)

   242

            target_name = self.GetDefaultTargetName()

   243

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

   244

        return target

   245

   246

    def GetParamsAttributes(self, path = None):

   247

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   248

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

   249

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

   250

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

   251

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

   252

        return params

   253

   254

    def SetParamsAttribute(self, path, value):

   255

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

   256

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

   257

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

   258

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

   259

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   260

        return res

   261

   262

    # helper func to check project path write permission

   263

    def CheckProjectPathPerm(self, dosave=True):

   264

        if CheckPathPerm(self.ProjectPath):

   265

            return True

   266

        if self.AppFrame is not None:

   267

            dialog = wx.MessageDialog(self.AppFrame,

   268

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

   269

                        _('Error'),

   270

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

   271

            answer = dialog.ShowModal()

   272

            dialog.Destroy()

   273

            if answer == wx.ID_YES:

   274

                if self.SaveProjectAs():

   275

                    self.AppFrame.RefreshTitle()

   276

                    self.AppFrame.RefreshFileMenu()

   277

                    self.AppFrame.RefreshPageTitles()

   278

                    return True

   279

        return False

   280

   281

    def _getProjectFilesPath(self, project_path=None):

   282

        if project_path is not None:

   283

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

   284

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

   285

        if not os.path.exists(projectfiles_path):

   286

            os.mkdir(projectfiles_path)

   287

        return projectfiles_path

   288

   289

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

   290

        self.ProjectAddConfiguration(config_name)

   291

        self.ProjectAddConfigurationResource(config_name, res_name)

   292

   293

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

   294

        """

   295

        Create a new project in an empty folder

   296

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

   297

        @param PLCParams: properties of the PLCOpen program created

   298

        """

   299

        # Verify that chosen folder is empty

   300

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

   301

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

   302

   303

        # Create PLCOpen program

   304

        self.CreateNewProject(

   305

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

   306

             "productName": _("Unnamed"),

   307

             "productVersion": "1",

   308

             "companyName": _("Unknown"),

   309

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

   310

        self.AddProjectDefaultConfiguration()

   311

   312

        # Change XSD into class members

   313

        self._AddParamsMembers()

   314

        self.Children = {}

   315

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

   316

        self.ProjectPath = ProjectPath

   317

        self._setBuildPath(BuildPath)

   318

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

   319

        self.RefreshConfNodesBlockLists()

   320

        # this will create files base XML files

   321

        self.SaveProject()

   322

        return None

   323

   324

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

   325

        """

   326

        Load a project contained in a folder

   327

        @param ProjectPath: path of the project folder

   328

        """

   329

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

   330

            ProjectPath = os.path.dirname(ProjectPath)

   331

        # Verify that project contains a PLCOpen program

   332

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

   333

        if not os.path.isfile(plc_file):

   334

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

   335

        # Load PLCOpen file

   336

        error = self.OpenXMLFile(plc_file)

   337

        if error is not None:

   338

            if self.Project is not None:

   339

                self.logger.write_warning(

   340

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

   341

            else:

   342

                return error

   343

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

   344

            self.AddProjectDefaultConfiguration()

   345

        # Change XSD into class members

   346

        self._AddParamsMembers()

   347

        self.Children = {}

   348

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

   349

        self.ProjectPath = ProjectPath

   350

        self._setBuildPath(BuildPath)

   351

        # If dir have already be made, and file exist

   352

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

   353

            #Load the confnode.xml file into parameters members

   354

            result = self.LoadXMLParams()

   355

            if result:

   356

                return result

   357

            #Load and init all the children

   358

            self.LoadChildren()

   359

        self.RefreshConfNodesBlockLists()

   360

   361

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

   362

            self.EnableMethod("_Clean", True)

   363

   364

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

   365

            self.ShowMethod("_showIECcode", True)

   366

   367

        self.UpdateMethodsFromPLCStatus()

   368

   369

        return None

   370

   371

    def RecursiveConfNodeInfos(self, confnode):

   372

        values = []

   373

        for CTNChild in confnode.IECSortedChildren():

   374

            values.append(

   375

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

   376

                                     CTNChild.CTNName()),

   377

                 "tagname": CTNChild.CTNFullName(),

   378

                 "type": ITEM_CONFNODE,

   379

                 "confnode": CTNChild,

   380

                 "icon": CTNChild.GetIconName(),

   381

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

   382

        return values

   383

   384

    def GetProjectInfos(self):

   385

        infos = PLCControler.GetProjectInfos(self)

   386

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

   387

        resources = None

   388

        for config_infos in configurations["values"]:

   389

            if resources is None:

   390

                resources = config_infos["values"][0]

   391

            else:

   392

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

   393

        if resources is not None:

   394

            infos["values"].append(resources)

   395

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

   396

        return infos

   397

   398

    def CloseProject(self):

   399

        self.ClearChildren()

   400

        self.ResetAppFrame(None)

   401

   402

    def SaveProject(self, from_project_path=None):

   403

        if self.CheckProjectPathPerm(False):

   404

            if from_project_path is not None:

   405

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   406

                if os.path.isdir(old_projectfiles_path):

   407

                    shutil.copytree(old_projectfiles_path,

   408

                                    self._getProjectFilesPath(self.ProjectPath))

   409

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

   410

            result = self.CTNRequestSave(from_project_path)

   411

            if result:

   412

                self.logger.write_error(result)

   413

   414

    def SaveProjectAs(self):

   415

        # Ask user to choose a path with write permissions

   416

        if wx.Platform == '__WXMSW__':

   417

            path = os.getenv("USERPROFILE")

   418

        else:

   419

            path = os.getenv("HOME")

   420

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

   421

        answer = dirdialog.ShowModal()

   422

        dirdialog.Destroy()

   423

        if answer == wx.ID_OK:

   424

            newprojectpath = dirdialog.GetPath()

   425

            if os.path.isdir(newprojectpath):

   426

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   427

                self.SaveProject(old_project_path)

   428

                self._setBuildPath(self.BuildPath)

   429

                return True

   430

        return False

   431

   432

    def GetLibrariesTypes(self):

   433

        self.LoadLibraries()

   434

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

   435

   436

    def GetLibrariesSTCode(self):

   437

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

   438

   439

    def GetLibrariesCCode(self, buildpath):

   440

        if len(self.Libraries)==0:

   441

            return [],[],()

   442

        self.GetIECProgramsAndVariables()

   443

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

   444

        LocatedCCodeAndFlags=[]

   445

        Extras=[]

   446

        for lib in self.Libraries:

   447

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

   448

            LocatedCCodeAndFlags.append(res[:2])

   449

            if len(res)>2:

   450

                Extras.extend(res[2:])

   451

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

   452

   453

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   454

    def RefreshConfNodesBlockLists(self):

   455

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

   456

            self.ClearConfNodeTypes()

   457

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   458

        if self.AppFrame is not None:

   459

            self.AppFrame.RefreshLibraryPanel()

   460

            self.AppFrame.RefreshEditor()

   461

   462

    # Update a PLCOpenEditor Pou variable location

   463

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   464

        self.Project.updateElementAddress(old_leading, new_leading)

   465

        self.BufferProject()

   466

        if self.AppFrame is not None:

   467

            self.AppFrame.RefreshTitle()

   468

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   469

            self.AppFrame.RefreshFileMenu()

   470

            self.AppFrame.RefreshEditMenu()

   471

            wx.CallAfter(self.AppFrame.RefreshEditor)

   472

   473

    def GetVariableLocationTree(self):

   474

        '''

   475

        This function is meant to be overridden by confnodes.

   476

   477

        It should returns an list of dictionaries

   478

   479

        - IEC_type is an IEC type like BOOL/BYTE/SINT/...

   480

        - location is a string of this variable's location, like "%IX0.0.0"