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.SetAppFrame(frame, logger)

    89

        self._builder = None

    90

        self._connector = None

    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

        self.previous_log_count = [None]*LogLevelsCount

   117

        # copy ConfNodeMethods so that it can be later customized

   118

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

   119

   120

    def LoadLibraries(self):

   121

        self.Libraries = []

   122

        TypeStack=[]

   123

        for libname,clsname in features.libraries:

   124

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

   125

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

   126

                TypeStack.append(Lib.GetTypes())

   127

                self.Libraries.append(Lib)

   128

   129

    def __del__(self):

   130

        if self.DebugTimer:

   131

            self.DebugTimer.cancel()

   132

        self.KillDebugThread()

   133

   134

    def SetAppFrame(self, frame, logger):

   135

        self.AppFrame = frame

   136

        self.logger = logger

   137

        self.StatusTimer = None

   138

   139

        if frame is not None:

   140

            # Timer to pull PLC status

   141

            ID_STATUSTIMER = wx.NewId()

   142

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

   143

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

   144

   145

            self.RefreshConfNodesBlockLists()

   146

   147

    def ResetAppFrame(self, logger):

   148

        if self.AppFrame is not None:

   149

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

   150

            self.StatusTimer = None

   151

            self.AppFrame = None

   152

   153

        self.logger = logger

   154

   155

    def CTNName(self):

   156

        return "Project"

   157

   158

    def CTNTestModified(self):

   159

         return self.ChangesToSave or not self.ProjectIsSaved()

   160

   161

    def CTNFullName(self):

   162

        return ""

   163

   164

    def GetCTRoot(self):

   165

        return self

   166

   167

    def GetIECLibPath(self):

   168

        return self.ieclib_path

   169

   170

    def GetIEC2cPath(self):

   171

        return self.iec2c_path

   172

   173

    def GetCurrentLocation(self):

   174

        return ()

   175

   176

    def GetCurrentName(self):

   177

        return ""

   178

   179

    def _GetCurrentName(self):

   180

        return ""

   181

   182

    def GetProjectPath(self):

   183

        return self.ProjectPath

   184

   185

    def GetProjectName(self):

   186

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

   187

   188

    def GetIconName(self):

   189

        return "PROJECT"

   190

   191

    def GetDefaultTargetName(self):

   192

        if wx.Platform == '__WXMSW__':

   193

            return "Win32"

   194

        else:

   195

            return "Linux"

   196

   197

    def GetTarget(self):

   198

        target = self.BeremizRoot.getTargetType()

   199

        if target.getcontent() is None:

   200

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

   201

            target_name = self.GetDefaultTargetName()

   202

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

   203

        return target

   204

   205

    def GetParamsAttributes(self, path = None):

   206

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   207

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

   208

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

   209

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

   210

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

   211

        return params

   212

   213

    def SetParamsAttribute(self, path, value):

   214

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

   215

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

   216

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   217

   218

    # helper func to check project path write permission

   219

    def CheckProjectPathPerm(self, dosave=True):

   220

        if CheckPathPerm(self.ProjectPath):

   221

            return True

   222

        dialog = wx.MessageDialog(self.AppFrame, 

   223

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

   224

                    _('Error'), 

   225

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

   226

        answer = dialog.ShowModal()

   227

        dialog.Destroy()

   228

        if answer == wx.ID_YES:

   229

            if self.SaveProjectAs():

   230

                self.AppFrame.RefreshTitle()

   231

                self.AppFrame.RefreshFileMenu()

   232

                self.AppFrame.RefreshPageTitles()

   233

                return True

   234

        return False

   235

   236

    def _getProjectFilesPath(self):

   237

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

   238

        if not os.path.exists(projectfiles_path):

   239

            os.mkdir(projectfiles_path)

   240

        return projectfiles_path

   241

   242

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

   243

        self.ProjectAddConfiguration(config_name)

   244

        self.ProjectAddConfigurationResource(config_name, res_name)

   245

   246

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

   247

        """

   248

        Create a new project in an empty folder

   249

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

   250

        @param PLCParams: properties of the PLCOpen program created

   251

        """

   252

        # Verify that chosen folder is empty

   253

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

   254

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

   255

   256

        # Create PLCOpen program

   257

        self.CreateNewProject(

   258

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

   259

             "productName": _("Unnamed"),

   260

             "productVersion": "1",

   261

             "companyName": _("Unknown"),

   262

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

   263

        self.AddProjectDefaultConfiguration()

   264

   265

        # Change XSD into class members

   266

        self._AddParamsMembers()

   267

        self.Children = {}

   268

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

   269

        self.ProjectPath = ProjectPath

   270

        self._setBuildPath(BuildPath)

   271

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

   272

        self.RefreshConfNodesBlockLists()

   273

        # this will create files base XML files

   274

        self.SaveProject()

   275

        return None

   276

   277

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

   278

        """

   279

        Load a project contained in a folder

   280

        @param ProjectPath: path of the project folder

   281

        """

   282

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

   283

            ProjectPath = os.path.dirname(ProjectPath)

   284

		# Verify that project contains a PLCOpen program

   285

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

   286

        if not os.path.isfile(plc_file):

   287

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

   288

        # Load PLCOpen file

   289

        result = self.OpenXMLFile(plc_file)

   290

        if result:

   291

            return result

   292

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

   293

            self.AddProjectDefaultConfiguration()

   294

        # Change XSD into class members

   295

        self._AddParamsMembers()

   296

        self.Children = {}

   297

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

   298

        self.ProjectPath = ProjectPath

   299

        self._setBuildPath(BuildPath)

   300

        # If dir have already be made, and file exist

   301

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

   302

            #Load the confnode.xml file into parameters members

   303

            result = self.LoadXMLParams()

   304

            if result:

   305

                return result

   306

            #Load and init all the children

   307

            self.LoadChildren()

   308

        self.RefreshConfNodesBlockLists()

   309

   310

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

   311

            self.EnableMethod("_Clean", True)

   312

   313

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

   314

            self.ShowMethod("_showIECcode", True)

   315

   316

        return None

   317

   318

    def RecursiveConfNodeInfos(self, confnode):

   319

        values = []

   320

        for CTNChild in confnode.IECSortedChildren():

   321

            values.append(

   322

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

   323

                                     CTNChild.CTNName()), 

   324

                 "type": ITEM_CONFNODE, 

   325

                 "confnode": CTNChild,

   326

                 "icon": CTNChild.GetIconName(),

   327

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

   328

        return values

   329

   330

    def GetProjectInfos(self):

   331

        infos = PLCControler.GetProjectInfos(self)

   332

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

   333

        resources = None

   334

        for config_infos in configurations["values"]:

   335

            if resources is None:

   336

                resources = config_infos["values"][0]

   337

            else:

   338

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

   339

        if resources is not None:

   340

            infos["values"].append(resources)

   341

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

   342

        return infos

   343

   344

    def CloseProject(self):

   345

        self.ClearChildren()

   346

        self.ResetAppFrame(None)

   347

   348

    def SaveProject(self):

   349

        if self.CheckProjectPathPerm(False):

   350

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

   351

            result = self.CTNRequestSave()

   352

            if result:

   353

                self.logger.write_error(result)

   354

   355

    def SaveProjectAs(self, dosave=True):

   356

        # Ask user to choose a path with write permissions

   357

        if wx.Platform == '__WXMSW__':

   358

            path = os.getenv("USERPROFILE")

   359

        else:

   360

            path = os.getenv("HOME")

   361

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

   362

        answer = dirdialog.ShowModal()

   363

        dirdialog.Destroy()

   364

        if answer == wx.ID_OK:

   365

            newprojectpath = dirdialog.GetPath()

   366

            if os.path.isdir(newprojectpath):

   367

                self.ProjectPath = newprojectpath

   368

                if dosave:

   369

                    self.SaveProject()

   370

                self._setBuildPath(self.BuildPath)

   371

                return True

   372

        return False

   373

   374

    def GetLibrariesTypes(self):

   375

        self.LoadLibraries()

   376

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

   377

   378

    def GetLibrariesSTCode(self):

   379

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

   380

   381

    def GetLibrariesCCode(self, buildpath):

   382

        if len(self.Libraries)==0:

   383

            return [],[],()

   384

        self.GetIECProgramsAndVariables()

   385

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

   386

        LocatedCCodeAndFlags=[]

   387

        Extras=[]

   388

        for lib in self.Libraries:

   389

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

   390

            LocatedCCodeAndFlags.append(res[:2])

   391

            if len(res)>2:

   392

                Extras.extend(res[2:])

   393

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

   394

   395

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   396

    def RefreshConfNodesBlockLists(self):

   397

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

   398

            self.ClearConfNodeTypes()

   399

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   400

        if self.AppFrame is not None:

   401

            self.AppFrame.RefreshLibraryPanel()

   402

            self.AppFrame.RefreshEditor()

   403

   404

    # Update a PLCOpenEditor Pou variable location

   405

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   406

        self.Project.updateElementAddress(old_leading, new_leading)

   407

        self.BufferProject()

   408

        if self.AppFrame is not None:

   409

            self.AppFrame.RefreshTitle()

   410

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   411

            self.AppFrame.RefreshFileMenu()

   412

            self.AppFrame.RefreshEditMenu()

   413

            wx.CallAfter(self.AppFrame.RefreshEditor)

   414

   415

    def GetVariableLocationTree(self):

   416

        '''

   417

        This function is meant to be overridden by confnodes.

   418

   419

        It should returns an list of dictionaries

   420

   421

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

   422

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

   423

        '''

   424

        children = []

   425

        for child in self.IECSortedChildren():

   426

            children.append(child.GetVariableLocationTree())

   427

        return children

   428

   429

    def ConfNodePath(self):

   430

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

   431

   432

    def CTNPath(self, CTNName=None):

   433

        return self.ProjectPath

   434

   435

    def ConfNodeXmlFilePath(self, CTNName=None):

   436

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

   437

   438

    def ParentsTypesFactory(self):

   439

        return self.ConfNodeTypesFactory()

   440

   441

    def _setBuildPath(self, buildpath):

   442

        if CheckPathPerm(buildpath):

   443

            self.BuildPath = buildpath

   444

        else:

   445

            self.BuildPath = None

   446

        self.BuildPath = buildpath

   447

        self.DefaultBuildPath = None

   448

        if self._builder is not None:

   449

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

   450

   451

    def _getBuildPath(self):

   452

        # BuildPath is defined by user

   453

        if self.BuildPath is not None:

   454

            return self.BuildPath

   455

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

   456

        if self.DefaultBuildPath is not None:

   457

            return self.DefaultBuildPath

   458

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

   459

        if CheckPathPerm(self.ProjectPath):

   460

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

   461

        # Create a build path in temp folder

   462

        else:

   463

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

   464

   465

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

   466

            os.makedirs(self.DefaultBuildPath)

   467

        return self.DefaultBuildPath

   468

   469

    def _getExtraFilesPath(self):

   470

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

   471

   472

    def _getIECcodepath(self):

   473

        # define name for IEC code file

   474

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

   475

   476

    def _getIECgeneratedcodepath(self):

   477

        # define name for IEC generated code file

   478

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

   479

   480

    def _getIECrawcodepath(self):

   481

        # define name for IEC raw code file

   482

        return os.path.join(self.CTNPath(), "raw_plc.st")

   483