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 threading import Timer, Lock, Thread

    11

from time import localtime

    12

from datetime import datetime

    13

from weakref import WeakKeyDictionary

    14

    15

import targets

    16

import connectors

    17

from util.misc import CheckPathPerm, GetClassImporter

    18

from util.MiniTextControler import MiniTextControler

    19

from util.ProcessLogger import ProcessLogger

    20

from util.BitmapLibrary import GetBitmap

    21

from editors.FileManagementPanel import FileManagementPanel

    22

from editors.ProjectNodeEditor import ProjectNodeEditor

    23

from editors.IECCodeViewer import IECCodeViewer

    24

from graphics import DebugViewer

    25

from dialogs import DiscoveryDialog

    26

from PLCControler import PLCControler

    27

from plcopen.structures import IEC_KEYWORDS

    28

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    29

from ConfigTreeNode import ConfigTreeNode

    30

    31

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

    32

    33

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

    34

    35

DEBUG_RETRIES_WARN = 3

    36

DEBUG_RETRIES_REREGISTER = 4

    37

    38

ITEM_CONFNODE = 25

    39

    40

class ProjectController(ConfigTreeNode, PLCControler):

    41

    """

    42

    This class define Root object of the confnode tree. 

    43

    It is responsible of :

    44

    - Managing project directory

    45

    - Building project

    46

    - Handling PLCOpenEditor controler and view

    47

    - Loading user confnodes and instanciante them as children

    48

    - ...

    49

    50

    """

    51

    52

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

    53

    CTNChildrenTypes =  [(n, GetClassImporter(c), d) for n,d,h,c in features.catalog]

    54

    55

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

    56

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

    57

      <xsd:element name="BeremizRoot">

    58

        <xsd:complexType>

    59

          <xsd:sequence>

    60

            <xsd:element name="TargetType">

    61

              <xsd:complexType>

    62

                <xsd:choice minOccurs="0">

    63

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

    64

                </xsd:choice>

    65

              </xsd:complexType>

    66

            </xsd:element>

    67

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

    68

              <xsd:complexType>

    69

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

    70

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

    71

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

    72

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

    73

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

    74

            </xsd:element>

    75

          </xsd:sequence>

    76

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

    77

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

    78

        </xsd:complexType>

    79

      </xsd:element>

    80

    </xsd:schema>

    81

    """

    82

    EditorType = ProjectNodeEditor

    83

    84

    def __init__(self, frame, logger):

    85

        PLCControler.__init__(self)

    86

    87

        self.MandatoryParams = None

    88

        self._builder = None

    89

        self._connector = None

    90

        self.SetAppFrame(frame, logger)

    91

    92

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

    93

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

    94

    95

        # Setup debug information

    96

        self.IECdebug_datas = {}

    97

        self.IECdebug_lock = Lock()

    98

    99

        self.DebugTimer=None

   100

        self.ResetIECProgramsAndVariables()

   101

   102

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

   103

        self.ChangesToSave = False

   104

        # root have no parent

   105

        self.CTNParent = None

   106

        # Keep track of the confnode type name

   107

        self.CTNType = "Beremiz"

   108

        self.Children = {}

   109

        self._View = None

   110

        # After __init__ root confnode is not valid

   111

        self.ProjectPath = None

   112

        self._setBuildPath(None)

   113

        self.DebugThread = None

   114

        self.debug_break = False

   115

        self.previous_plcstate = None

   116

        # copy ConfNodeMethods so that it can be later customized

   117

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

   118

   119

    def LoadLibraries(self):

   120

        self.Libraries = []

   121

        TypeStack=[]

   122

        for libname,clsname in features.libraries:

   123

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

   124

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

   125

                TypeStack.append(Lib.GetTypes())

   126

                self.Libraries.append(Lib)

   127

   128

    def __del__(self):

   129

        if self.DebugTimer:

   130

            self.DebugTimer.cancel()

   131

        self.KillDebugThread()

   132

   133

    def SetAppFrame(self, frame, logger):

   134

        self.AppFrame = frame

   135

        self.logger = logger

   136

        self.StatusTimer = None

   137

   138

        if frame is not None:

   139

            frame.LogViewer.SetLogSource(self._connector)

   140

   141

            # Timer to pull PLC status

   142

            ID_STATUSTIMER = wx.NewId()

   143

            self.StatusTimer = wx.Timer(self.AppFrame, ID_STATUSTIMER)

   144

            self.AppFrame.Bind(wx.EVT_TIMER, self.PullPLCStatusProc, self.StatusTimer)

   145

   146

            self.RefreshConfNodesBlockLists()

   147

   148

    def ResetAppFrame(self, logger):

   149

        if self.AppFrame is not None:

   150

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

   151

            self.StatusTimer = None

   152

            self.AppFrame = None

   153

   154

        self.logger = logger

   155

   156

    def CTNName(self):

   157

        return "Project"

   158

   159

    def CTNTestModified(self):

   160

         return self.ChangesToSave or not self.ProjectIsSaved()

   161

   162

    def CTNFullName(self):

   163

        return ""

   164

   165

    def GetCTRoot(self):

   166

        return self

   167

   168

    def GetIECLibPath(self):

   169

        return self.ieclib_path

   170

   171

    def GetIEC2cPath(self):

   172

        return self.iec2c_path

   173

   174

    def GetCurrentLocation(self):

   175

        return ()

   176

   177

    def GetCurrentName(self):

   178

        return ""

   179

   180

    def _GetCurrentName(self):

   181

        return ""

   182

   183

    def GetProjectPath(self):

   184

        return self.ProjectPath

   185

   186

    def GetProjectName(self):

   187

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

   188

   189

    def GetIconName(self):

   190

        return "PROJECT"

   191

   192

    def GetDefaultTargetName(self):

   193

        if wx.Platform == '__WXMSW__':

   194

            return "Win32"

   195

        else:

   196

            return "Linux"

   197

   198

    def GetTarget(self):

   199

        target = self.BeremizRoot.getTargetType()

   200

        if target.getcontent() is None:

   201

            target = self.Classes["BeremizRoot_TargetType"]()

   202

            target_name = self.GetDefaultTargetName()

   203

            target.setcontent({"name": target_name, "value": self.Classes["TargetType_%s"%target_name]()})

   204

        return target

   205

   206

    def GetParamsAttributes(self, path = None):

   207

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   208

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

   209

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

   210

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

   211

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

   212

        return params

   213

   214

    def SetParamsAttribute(self, path, value):

   215

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

   216

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

   217

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   218

   219

    # helper func to check project path write permission

   220

    def CheckProjectPathPerm(self, dosave=True):

   221

        if CheckPathPerm(self.ProjectPath):

   222

            return True

   223

        dialog = wx.MessageDialog(self.AppFrame, 

   224

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

   225

                    _('Error'), 

   226

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

   227

        answer = dialog.ShowModal()

   228

        dialog.Destroy()

   229

        if answer == wx.ID_YES:

   230

            if self.SaveProjectAs():

   231

                self.AppFrame.RefreshTitle()

   232

                self.AppFrame.RefreshFileMenu()

   233

                self.AppFrame.RefreshPageTitles()

   234

                return True

   235

        return False

   236

   237

    def _getProjectFilesPath(self):

   238

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

   239

        if not os.path.exists(projectfiles_path):

   240

            os.mkdir(projectfiles_path)

   241

        return projectfiles_path

   242

   243

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

   244

        self.ProjectAddConfiguration(config_name)

   245

        self.ProjectAddConfigurationResource(config_name, res_name)

   246

   247

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

   248

        """

   249

        Create a new project in an empty folder

   250

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

   251

        @param PLCParams: properties of the PLCOpen program created

   252

        """

   253

        # Verify that chosen folder is empty

   254

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

   255

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

   256

   257

        # Create PLCOpen program

   258

        self.CreateNewProject(

   259

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

   260

             "productName": _("Unnamed"),

   261

             "productVersion": "1",

   262

             "companyName": _("Unknown"),

   263

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

   264

        self.AddProjectDefaultConfiguration()

   265

   266

        # Change XSD into class members

   267

        self._AddParamsMembers()

   268

        self.Children = {}

   269

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

   270

        self.ProjectPath = ProjectPath

   271

        self._setBuildPath(BuildPath)

   272

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

   273

        self.RefreshConfNodesBlockLists()

   274

        # this will create files base XML files

   275

        self.SaveProject()

   276

        return None

   277

   278

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

   279

        """

   280

        Load a project contained in a folder

   281

        @param ProjectPath: path of the project folder

   282

        """

   283

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

   284

            ProjectPath = os.path.dirname(ProjectPath)

   285

        # Verify that project contains a PLCOpen program

   286

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

   287

        if not os.path.isfile(plc_file):

   288

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

   289

        # Load PLCOpen file

   290

        result = self.OpenXMLFile(plc_file)

   291

        if result:

   292

            return result

   293

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

   294

            self.AddProjectDefaultConfiguration()

   295

        # Change XSD into class members

   296

        self._AddParamsMembers()

   297

        self.Children = {}

   298

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

   299

        self.ProjectPath = ProjectPath

   300

        self._setBuildPath(BuildPath)

   301

        # If dir have already be made, and file exist

   302

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

   303

            #Load the confnode.xml file into parameters members

   304

            result = self.LoadXMLParams()

   305

            if result:

   306

                return result

   307

            #Load and init all the children

   308

            self.LoadChildren()

   309

        self.RefreshConfNodesBlockLists()

   310

   311

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

   312

            self.EnableMethod("_Clean", True)

   313

   314

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

   315

            self.ShowMethod("_showIECcode", True)

   316

   317

        self.UpdateMethodsFromPLCStatus()

   318

   319

        return None

   320

   321

    def RecursiveConfNodeInfos(self, confnode):

   322

        values = []

   323

        for CTNChild in confnode.IECSortedChildren():

   324

            values.append(

   325

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

   326

                                     CTNChild.CTNName()), 

   327

                 "type": ITEM_CONFNODE, 

   328

                 "confnode": CTNChild,

   329

                 "icon": CTNChild.GetIconName(),

   330

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

   331

        return values

   332

   333

    def GetProjectInfos(self):

   334

        infos = PLCControler.GetProjectInfos(self)

   335

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

   336

        resources = None

   337

        for config_infos in configurations["values"]:

   338

            if resources is None:

   339

                resources = config_infos["values"][0]

   340

            else:

   341

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

   342

        if resources is not None:

   343

            infos["values"].append(resources)

   344

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

   345

        return infos

   346

   347

    def CloseProject(self):

   348

        self.ClearChildren()

   349

        self.ResetAppFrame(None)

   350

   351

    def SaveProject(self):

   352

        if self.CheckProjectPathPerm(False):

   353

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

   354

            result = self.CTNRequestSave()

   355

            if result:

   356

                self.logger.write_error(result)

   357

   358

    def SaveProjectAs(self, dosave=True):

   359

        # Ask user to choose a path with write permissions

   360

        if wx.Platform == '__WXMSW__':

   361

            path = os.getenv("USERPROFILE")

   362

        else:

   363

            path = os.getenv("HOME")

   364

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

   365

        answer = dirdialog.ShowModal()

   366

        dirdialog.Destroy()

   367

        if answer == wx.ID_OK:

   368

            newprojectpath = dirdialog.GetPath()

   369

            if os.path.isdir(newprojectpath):

   370

                self.ProjectPath = newprojectpath

   371

                if dosave:

   372

                    self.SaveProject()

   373

                self._setBuildPath(self.BuildPath)

   374

                return True

   375

        return False

   376

   377

    def GetLibrariesTypes(self):

   378

        self.LoadLibraries()

   379

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

   380

   381

    def GetLibrariesSTCode(self):

   382

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

   383

   384

    def GetLibrariesCCode(self, buildpath):

   385

        if len(self.Libraries)==0:

   386

            return [],[],()

   387

        self.GetIECProgramsAndVariables()

   388

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

   389

        LocatedCCodeAndFlags=[]

   390

        Extras=[]

   391

        for lib in self.Libraries:

   392

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

   393

            LocatedCCodeAndFlags.append(res[:2])

   394

            if len(res)>2:

   395

                Extras.extend(res[2:])

   396

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

   397

   398

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   399

    def RefreshConfNodesBlockLists(self):

   400

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

   401

            self.ClearConfNodeTypes()

   402

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   403

        if self.AppFrame is not None:

   404

            self.AppFrame.RefreshLibraryPanel()

   405

            self.AppFrame.RefreshEditor()

   406

   407

    # Update a PLCOpenEditor Pou variable location

   408

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   409

        self.Project.updateElementAddress(old_leading, new_leading)

   410

        self.BufferProject()

   411

        if self.AppFrame is not None:

   412

            self.AppFrame.RefreshTitle()

   413

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   414

            self.AppFrame.RefreshFileMenu()

   415

            self.AppFrame.RefreshEditMenu()

   416

            wx.CallAfter(self.AppFrame.RefreshEditor)

   417

   418

    def GetVariableLocationTree(self):

   419

        '''

   420

        This function is meant to be overridden by confnodes.

   421

   422

        It should returns an list of dictionaries

   423

   424

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

   425

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

   426

        '''

   427

        children = []

   428

        for child in self.IECSortedChildren():

   429

            children.append(child.GetVariableLocationTree())

   430

        return children

   431

   432

    def ConfNodePath(self):

   433

        return os.path.split(__file__)[0]

   434

   435

    def CTNPath(self, CTNName=None):

   436

        return self.ProjectPath

   437

   438

    def ConfNodeXmlFilePath(self, CTNName=None):

   439

        return os.path.join(self.CTNPath(CTNName), "beremiz.xml")

   440

   441

    def ParentsTypesFactory(self):

   442

        return self.ConfNodeTypesFactory()

   443

   444

    def _setBuildPath(self, buildpath):

   445

        if CheckPathPerm(buildpath):

   446

            self.BuildPath = buildpath

   447

        else:

   448

            self.BuildPath = None

   449

        self.BuildPath = buildpath

   450

        self.DefaultBuildPath = None

   451

        if self._builder is not None:

   452

            self._builder.SetBuildPath(self._getBuildPath())

   453

   454

    def _getBuildPath(self):

   455

        # BuildPath is defined by user

   456

        if self.BuildPath is not None:

   457

            return self.BuildPath

   458

        # BuildPath isn't defined by user but already created by default

   459

        if self.DefaultBuildPath is not None:

   460

            return self.DefaultBuildPath

   461

        # Create a build path in project folder if user has permissions

   462

        if CheckPathPerm(self.ProjectPath):

   463

            self.DefaultBuildPath = os.path.join(self.ProjectPath, "build")

   464

        # Create a build path in temp folder

   465

        else:

   466

            self.DefaultBuildPath = os.path.join(tempfile.mkdtemp(), os.path.basename(self.ProjectPath), "build")

   467

   468

        if not os.path.exists(self.DefaultBuildPath):

   469

            os.makedirs(self.DefaultBuildPath)

   470

        return self.DefaultBuildPath

   471

   472

    def _getExtraFilesPath(self):

   473

        return os.path.join(self._getBuildPath(), "extra_files")

   474

   475

    def _getIECcodepath(self):

   476

        # define name for IEC code file

   477

        return os.path.join(self._getBuildPath(), "plc.st")

   478

   479

    def _getIECgeneratedcodepath(self):

   480

        # define name for IEC generated code file

   481

        return os.path.join(self._getBuildPath(), "generated_plc.st")

   482

   483

    def _getIECrawcodepath(self):