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, project_path=None):

   238

        if project_path is not None:

   239

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

   240

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

   241

        if not os.path.exists(projectfiles_path):

   242

            os.mkdir(projectfiles_path)

   243

        return projectfiles_path

   244

   245

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

   246

        self.ProjectAddConfiguration(config_name)

   247

        self.ProjectAddConfigurationResource(config_name, res_name)

   248

   249

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

   250

        """

   251

        Create a new project in an empty folder

   252

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

   253

        @param PLCParams: properties of the PLCOpen program created

   254

        """

   255

        # Verify that chosen folder is empty

   256

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

   257

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

   258

   259

        # Create PLCOpen program

   260

        self.CreateNewProject(

   261

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

   262

             "productName": _("Unnamed"),

   263

             "productVersion": "1",

   264

             "companyName": _("Unknown"),

   265

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

   266

        self.AddProjectDefaultConfiguration()

   267

   268

        # Change XSD into class members

   269

        self._AddParamsMembers()

   270

        self.Children = {}

   271

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

   272

        self.ProjectPath = ProjectPath

   273

        self._setBuildPath(BuildPath)

   274

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

   275

        self.RefreshConfNodesBlockLists()

   276

        # this will create files base XML files

   277

        self.SaveProject()

   278

        return None

   279

   280

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

   281

        """

   282

        Load a project contained in a folder

   283

        @param ProjectPath: path of the project folder

   284

        """

   285

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

   286

            ProjectPath = os.path.dirname(ProjectPath)

   287

        # Verify that project contains a PLCOpen program

   288

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

   289

        if not os.path.isfile(plc_file):

   290

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

   291

        # Load PLCOpen file

   292

        result = self.OpenXMLFile(plc_file)

   293

        if result:

   294

            return result

   295

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

   296

            self.AddProjectDefaultConfiguration()

   297

        # Change XSD into class members

   298

        self._AddParamsMembers()

   299

        self.Children = {}

   300

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

   301

        self.ProjectPath = ProjectPath

   302

        self._setBuildPath(BuildPath)

   303

        # If dir have already be made, and file exist

   304

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

   305

            #Load the confnode.xml file into parameters members

   306

            result = self.LoadXMLParams()

   307

            if result:

   308

                return result

   309

            #Load and init all the children

   310

            self.LoadChildren()

   311

        self.RefreshConfNodesBlockLists()

   312

   313

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

   314

            self.EnableMethod("_Clean", True)

   315

   317

            self.ShowMethod("_showIECcode", True)

   318

   319

        self.UpdateMethodsFromPLCStatus()

   320

   321

        return None

   322

   323

    def RecursiveConfNodeInfos(self, confnode):

   324

        values = []

   325

        for CTNChild in confnode.IECSortedChildren():

   326

            values.append(

   327

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

   328

                                     CTNChild.CTNName()), 

   329

                 "type": ITEM_CONFNODE, 

   330

                 "confnode": CTNChild,

   331

                 "icon": CTNChild.GetIconName(),

   332

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

   333

        return values

   334

   335

    def GetProjectInfos(self):

   336

        infos = PLCControler.GetProjectInfos(self)

   337

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

   338

        resources = None

   339

        for config_infos in configurations["values"]:

   340

            if resources is None:

   341

                resources = config_infos["values"][0]

   342

            else:

   343

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

   344

        if resources is not None:

   345

            infos["values"].append(resources)

   346

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

   347

        return infos

   348

   349

    def CloseProject(self):

   350

        self.ClearChildren()

   351

        self.ResetAppFrame(None)

   352

   353

    def SaveProject(self, from_project_path=None):

   354

        if self.CheckProjectPathPerm(False):

   355

            if from_project_path is not None:

   356

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   357

                if os.path.isdir(old_projectfiles_path):

   358

                    shutil.copytree(old_projectfiles_path, 

   359

                                    self._getProjectFilesPath(self.ProjectPath))

   360

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

   361

            result = self.CTNRequestSave(from_project_path)

   362

            if result:

   363

                self.logger.write_error(result)

   364

   365

    def SaveProjectAs(self):

   366

        # Ask user to choose a path with write permissions

   367

        if wx.Platform == '__WXMSW__':

   368

            path = os.getenv("USERPROFILE")

   369

        else:

   370

            path = os.getenv("HOME")

   371

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

   372

        answer = dirdialog.ShowModal()

   373

        dirdialog.Destroy()

   374

        if answer == wx.ID_OK:

   375

            newprojectpath = dirdialog.GetPath()

   376

            if os.path.isdir(newprojectpath):

   377

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   378

                self.SaveProject(old_project_path)

   379

                self._setBuildPath(self.BuildPath)

   380

                return True

   381

        return False

   382

   383

    def GetLibrariesTypes(self):

   384

        self.LoadLibraries()

   385

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

   386

   387

    def GetLibrariesSTCode(self):

   388

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

   389

   390

    def GetLibrariesCCode(self, buildpath):

   391

        if len(self.Libraries)==0:

   392

            return [],[],()

   393

        self.GetIECProgramsAndVariables()

   394

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

   395

        LocatedCCodeAndFlags=[]

   396

        Extras=[]

   397

        for lib in self.Libraries:

   398

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

   399

            LocatedCCodeAndFlags.append(res[:2])

   400

            if len(res)>2:

   401

                Extras.extend(res[2:])

   402

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

   403

   404

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   405

    def RefreshConfNodesBlockLists(self):

   406

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

   407

            self.ClearConfNodeTypes()

   408

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   409

        if self.AppFrame is not None:

   410

            self.AppFrame.RefreshLibraryPanel()

   411

            self.AppFrame.RefreshEditor()

   412

   413

    # Update a PLCOpenEditor Pou variable location

   414

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   415

        self.Project.updateElementAddress(old_leading, new_leading)

   416

        self.BufferProject()

   417

        if self.AppFrame is not None:

   418

            self.AppFrame.RefreshTitle()

   419

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   420

            self.AppFrame.RefreshFileMenu()

   421

            self.AppFrame.RefreshEditMenu()

   422

            wx.CallAfter(self.AppFrame.RefreshEditor)

   423

   424

    def GetVariableLocationTree(self):

   425

        '''

   426

        This function is meant to be overridden by confnodes.

   427

   428

        It should returns an list of dictionaries

   429

   430

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

   431

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

   432

        '''

   433

        children = []

   434

        for child in self.IECSortedChildren():

   435

            children.append(child.GetVariableLocationTree())

   436

        return children

   437

   438

    def ConfNodePath(self):

   439

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

   440

   441

    def CTNPath(self, CTNName=None):

   442

        return self.ProjectPath

   443

   444

    def ConfNodeXmlFilePath(self, CTNName=None):

   445

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

   446

   447

    def ParentsTypesFactory(self):

   448

        return self.ConfNodeTypesFactory()

   449

   450

    def _setBuildPath(self, buildpath):

   451

        if CheckPathPerm(buildpath):

   452

            self.BuildPath = buildpath

   453

        else:

   454

            self.BuildPath = None

   455

        self.BuildPath = buildpath

   456

        self.DefaultBuildPath = None

   457

        if self._builder is not None:

   458

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

   459

   460

    def _getBuildPath(self):

   461

        # BuildPath is defined by user

   462

        if self.BuildPath is not None:

   463

            return self.BuildPath

   464

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

   465

        if self.DefaultBuildPath is not None:

   466

            return self.DefaultBuildPath

   467

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

   468

        if CheckPathPerm(self.ProjectPath):

   469

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

   470

        # Create a build path in temp folder

   471

        else:

   472

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

   473

   474

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

   475

            os.makedirs(self.DefaultBuildPath)

   476

        return self.DefaultBuildPath

   477

   478

    def _getExtraFilesPath(self):

   479

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

   480

   481

    def _getIECcodepath(self):

   482

        # define name for IEC code file