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

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

   218

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

   219

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   220

        return res

   221

   222

    # helper func to check project path write permission

   223

    def CheckProjectPathPerm(self, dosave=True):

   224

        if CheckPathPerm(self.ProjectPath):

   225

            return True

   226

        if self.AppFrame is not None:

   227

            dialog = wx.MessageDialog(self.AppFrame, 

   228

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

   229

                        _('Error'), 

   230

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

   231

            answer = dialog.ShowModal()

   232

            dialog.Destroy()

   233

            if answer == wx.ID_YES:

   234

                if self.SaveProjectAs():

   235

                    self.AppFrame.RefreshTitle()

   236

                    self.AppFrame.RefreshFileMenu()

   237

                    self.AppFrame.RefreshPageTitles()

   238

                    return True

   239

        return False

   240

   241

    def _getProjectFilesPath(self, project_path=None):

   242

        if project_path is not None:

   243

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

   244

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

   245

        if not os.path.exists(projectfiles_path):

   246

            os.mkdir(projectfiles_path)

   247

        return projectfiles_path

   248

   249

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

   250

        self.ProjectAddConfiguration(config_name)

   251

        self.ProjectAddConfigurationResource(config_name, res_name)

   252

   253

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

   254

        """

   255

        Create a new project in an empty folder

   256

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

   257

        @param PLCParams: properties of the PLCOpen program created

   258

        """

   259

        # Verify that chosen folder is empty

   260

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

   261

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

   262

   263

        # Create PLCOpen program

   264

        self.CreateNewProject(

   265

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

   266

             "productName": _("Unnamed"),

   267

             "productVersion": "1",

   268

             "companyName": _("Unknown"),

   269

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

   270

        self.AddProjectDefaultConfiguration()

   271

   272

        # Change XSD into class members

   273

        self._AddParamsMembers()

   274

        self.Children = {}

   275

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

   276

        self.ProjectPath = ProjectPath

   277

        self._setBuildPath(BuildPath)

   278

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

   279

        self.RefreshConfNodesBlockLists()

   280

        # this will create files base XML files

   281

        self.SaveProject()

   282

        return None

   283

   284

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

   285

        """

   286

        Load a project contained in a folder

   287

        @param ProjectPath: path of the project folder

   288

        """

   289

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

   290

            ProjectPath = os.path.dirname(ProjectPath)

   291

        # Verify that project contains a PLCOpen program

   292

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

   293

        if not os.path.isfile(plc_file):

   294

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

   295

        # Load PLCOpen file

   296

        result = self.OpenXMLFile(plc_file)

   297

        if result:

   298

            return result

   299

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

   300

            self.AddProjectDefaultConfiguration()

   301

        # Change XSD into class members

   302

        self._AddParamsMembers()

   303

        self.Children = {}

   304

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

   305

        self.ProjectPath = ProjectPath

   306

        self._setBuildPath(BuildPath)

   307

        # If dir have already be made, and file exist

   308

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

   309

            #Load the confnode.xml file into parameters members

   310

            result = self.LoadXMLParams()

   311

            if result:

   312

                return result

   313

            #Load and init all the children

   314

            self.LoadChildren()

   315

        self.RefreshConfNodesBlockLists()

   316

   317

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

   318

            self.EnableMethod("_Clean", True)

   319

   320

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

   321

            self.ShowMethod("_showIECcode", True)

   322

   323

        self.UpdateMethodsFromPLCStatus()

   324

   325

        return None

   326

   327

    def RecursiveConfNodeInfos(self, confnode):

   328

        values = []

   329

        for CTNChild in confnode.IECSortedChildren():

   330

            values.append(

   331

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

   332

                                     CTNChild.CTNName()), 

   333

                 "tagname": CTNChild.CTNFullName(),

   334

                 "type": ITEM_CONFNODE, 

   335

                 "confnode": CTNChild,

   336

                 "icon": CTNChild.GetIconName(),

   337

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

   338

        return values

   339

   340

    def GetProjectInfos(self):

   341

        infos = PLCControler.GetProjectInfos(self)

   342

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

   343

        resources = None

   344

        for config_infos in configurations["values"]:

   345

            if resources is None:

   346

                resources = config_infos["values"][0]

   347

            else:

   348

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

   349

        if resources is not None:

   350

            infos["values"].append(resources)

   351

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

   352

        return infos

   353

   354

    def CloseProject(self):

   355

        self.ClearChildren()

   356

        self.ResetAppFrame(None)

   357

   358

    def SaveProject(self, from_project_path=None):

   359

        if self.CheckProjectPathPerm(False):

   360

            if from_project_path is not None:

   361

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   362

                if os.path.isdir(old_projectfiles_path):

   363

                    shutil.copytree(old_projectfiles_path, 

   364

                                    self._getProjectFilesPath(self.ProjectPath))

   365

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

   366

            result = self.CTNRequestSave(from_project_path)

   367

            if result:

   368

                self.logger.write_error(result)

   369

   370

    def SaveProjectAs(self):

   371

        # Ask user to choose a path with write permissions

   372

        if wx.Platform == '__WXMSW__':

   373

            path = os.getenv("USERPROFILE")

   374

        else:

   375

            path = os.getenv("HOME")

   376

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

   377

        answer = dirdialog.ShowModal()

   378

        dirdialog.Destroy()

   379

        if answer == wx.ID_OK:

   380

            newprojectpath = dirdialog.GetPath()

   381

            if os.path.isdir(newprojectpath):

   382

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   383

                self.SaveProject(old_project_path)

   384

                self._setBuildPath(self.BuildPath)

   385

                return True

   386

        return False

   387

   388

    def GetLibrariesTypes(self):

   389

        self.LoadLibraries()

   390

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

   391

   392

    def GetLibrariesSTCode(self):

   393

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

   394

   395

    def GetLibrariesCCode(self, buildpath):

   396

        if len(self.Libraries)==0:

   397

            return [],[],()

   398

        self.GetIECProgramsAndVariables()

   399

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

   400

        LocatedCCodeAndFlags=[]

   401

        Extras=[]

   402

        for lib in self.Libraries:

   403

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

   404

            LocatedCCodeAndFlags.append(res[:2])

   405

            if len(res)>2:

   406

                Extras.extend(res[2:])

   407

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

   408

   409

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   410

    def RefreshConfNodesBlockLists(self):

   411

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

   412

            self.ClearConfNodeTypes()

   413

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   414

        if self.AppFrame is not None:

   415

            self.AppFrame.RefreshLibraryPanel()

   416

            self.AppFrame.RefreshEditor()

   417

   418

    # Update a PLCOpenEditor Pou variable location

   419

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   420

        self.Project.updateElementAddress(old_leading, new_leading)

   421

        self.BufferProject()

   422

        if self.AppFrame is not None:

   423

            self.AppFrame.RefreshTitle()

   424

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   425

            self.AppFrame.RefreshFileMenu()

   426

            self.AppFrame.RefreshEditMenu()

   427

            wx.CallAfter(self.AppFrame.RefreshEditor)

   428

   429

    def GetVariableLocationTree(self):

   430

        '''

   431

        This function is meant to be overridden by confnodes.

   432

   433

        It should returns an list of dictionaries

   434

   435

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

   436

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

   437

        '''

   438

        children = []

   439

        for child in self.IECSortedChildren():

   440

            children.append(child.GetVariableLocationTree())

   441

        return children

   442

   443

    def ConfNodePath(self):

   444

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

   445

   446

    def CTNPath(self, CTNName=None):

   447

        return self.ProjectPath

   448

   449

    def ConfNodeXmlFilePath(self, CTNName=None):

   450

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

   451

   452

    def ParentsTypesFactory(self):

   453

        return self.ConfNodeTypesFactory()

   454

   455

    def _setBuildPath(self, buildpath):

   456

        if CheckPathPerm(buildpath):

   457

            self.BuildPath = buildpath

   458

        else:

   459

            self.BuildPath = None

   460

        self.BuildPath = buildpath

   461

        self.DefaultBuildPath = None

   462

        if self._builder is not None:

   463

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

   464

   465

    def _getBuildPath(self):

   466

        # BuildPath is defined by user

   467

        if self.BuildPath is not None:

   468

            return self.BuildPath

   469

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

   470

        if self.DefaultBuildPath is not None:

   471

            return self.DefaultBuildPath

   472

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

   473

        if CheckPathPerm(self.ProjectPath):

   474

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

   475

        # Create a build path in temp folder

   476

        else:

   477

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

   478

   479

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

   480

            os.makedirs(self.DefaultBuildPath)

   481

        return self.DefaultBuildPath

   482

   483