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 dialogs import DiscoveryDialog

    25

from PLCControler import PLCControler

    26

from plcopen.structures import IEC_KEYWORDS

    27

from targets.typemapping import DebugTypesSize

    28

from ConfigTreeNode import ConfigTreeNode

    29

    30

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

    31

    32

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

    33

    34

DEBUG_RETRIES_WARN = 3

    35

DEBUG_RETRIES_REREGISTER = 4

    36

    37

ITEM_CONFNODE = 25

    38

    39

class ProjectController(ConfigTreeNode, PLCControler):

    40

    """

    41

    This class define Root object of the confnode tree. 

    42

    It is responsible of :

    43

    - Managing project directory

    44

    - Building project

    45

    - Handling PLCOpenEditor controler and view

    46

    - Loading user confnodes and instanciante them as children

    47

    - ...

    48

    49

    """

    50

    51

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

    52

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

    53

    54

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

    55

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

    56

      <xsd:element name="BeremizRoot">

    57

        <xsd:complexType>

    58

          <xsd:sequence>

    59

            <xsd:element name="TargetType">

    60

              <xsd:complexType>

    61

                <xsd:choice minOccurs="0">

    62

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

    63

                </xsd:choice>

    64

              </xsd:complexType>

    65

            </xsd:element>

    66

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

    67

              <xsd:complexType>

    68

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

    69

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

    70

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

    71

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

    72

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

    73

            </xsd:element>

    74

          </xsd:sequence>

    75

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

    76

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

    77

        </xsd:complexType>

    78

      </xsd:element>

    79

    </xsd:schema>

    80

    """

    81

    EditorType = ProjectNodeEditor

    82

    83

    def __init__(self, frame, logger):

    84

        PLCControler.__init__(self)

    85

    86

        self.MandatoryParams = None

    87

        self.SetAppFrame(frame, logger)

    88

        self._builder = None

    89

        self._connector = None

    90

    91

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

    92

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

    93

    94

        # Setup debug information

    95

        self.IECdebug_datas = {}

    96

        self.IECdebug_lock = Lock()

    97

    98

        self.DebugTimer=None

    99

        self.ResetIECProgramsAndVariables()

   100

   101

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

   102

        self.ChangesToSave = False

   103

        # root have no parent

   104

        self.CTNParent = None

   105

        # Keep track of the confnode type name

   106

        self.CTNType = "Beremiz"

   107

        self.Children = {}

   108

        self._View = None

   109

        # After __init__ root confnode is not valid

   110

        self.ProjectPath = None

   111

        self._setBuildPath(None)

   112

        self.DebugThread = None

   113

        self.debug_break = False

   114

        self.previous_plcstate = None

   115

        # copy ConfNodeMethods so that it can be later customized

   116

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

   117

   118

    def LoadLibraries(self):

   119

        self.Libraries = []

   120

        TypeStack=[]

   121

        for libname,clsname in features.libraries:

   122

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

   123

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

   124

                TypeStack.append(Lib.GetTypes())

   125

                self.Libraries.append(Lib)

   126

   127

    def __del__(self):

   128

        if self.DebugTimer:

   129

            self.DebugTimer.cancel()

   130

        self.KillDebugThread()

   131

   132

    def SetAppFrame(self, frame, logger):

   133

        self.AppFrame = frame

   134

        self.logger = logger

   135

        self.StatusTimer = None

   136

   137

        if frame is not None:

   138

            # Timer to pull PLC status

   139

            ID_STATUSTIMER = wx.NewId()

   140

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

   141

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

   142

   143

            self.RefreshConfNodesBlockLists()

   144

   145

    def ResetAppFrame(self, logger):

   146

        if self.AppFrame is not None:

   147

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

   148

            self.StatusTimer = None

   149

            self.AppFrame = None

   150

   151

        self.logger = logger

   152

   153

    def CTNName(self):

   154

        return "Project"

   155

   156

    def CTNTestModified(self):

   157

         return self.ChangesToSave or not self.ProjectIsSaved()

   158

   159

    def CTNFullName(self):

   160

        return ""

   161

   162

    def GetCTRoot(self):

   163

        return self

   164

   165

    def GetIECLibPath(self):

   166

        return self.ieclib_path

   167

   168

    def GetIEC2cPath(self):

   169

        return self.iec2c_path

   170

   171

    def GetCurrentLocation(self):

   172

        return ()

   173

   174

    def GetCurrentName(self):

   175

        return ""

   176

   177

    def _GetCurrentName(self):

   178

        return ""

   179

   180

    def GetProjectPath(self):

   181

        return self.ProjectPath

   182

   183

    def GetProjectName(self):

   184

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

   185

   186

    def GetIconName(self):

   187

        return "PROJECT"

   188

   189

    def GetDefaultTargetName(self):

   190

        if wx.Platform == '__WXMSW__':

   191

            return "Win32"

   192

        else:

   193

            return "Linux"

   194

   195

    def GetTarget(self):

   196

        target = self.BeremizRoot.getTargetType()

   197

        if target.getcontent() is None:

   198

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

   199

            target_name = self.GetDefaultTargetName()

   200

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

   201

        return target

   202

   203

    def GetParamsAttributes(self, path = None):

   204

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   205

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

   206

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

   207

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

   208

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

   209

        return params

   210

   211

    def SetParamsAttribute(self, path, value):

   212

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

   213

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

   214

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   215

   216

    # helper func to check project path write permission

   217

    def CheckProjectPathPerm(self, dosave=True):

   218

        if CheckPathPerm(self.ProjectPath):

   219

            return True

   220

        dialog = wx.MessageDialog(self.AppFrame, 

   221

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

   222

                    _('Error'), 

   223

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

   224

        answer = dialog.ShowModal()

   225

        dialog.Destroy()

   226

        if answer == wx.ID_YES:

   227

            if self.SaveProjectAs():

   228

                self.AppFrame.RefreshTitle()

   229

                self.AppFrame.RefreshFileMenu()

   230

                self.AppFrame.RefreshPageTitles()

   231

                return True

   232

        return False

   233

   234

    def _getProjectFilesPath(self):

   235

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

   236

        if not os.path.exists(projectfiles_path):

   237

            os.mkdir(projectfiles_path)

   238

        return projectfiles_path

   239

   240

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

   241

        self.ProjectAddConfiguration(config_name)

   242

        self.ProjectAddConfigurationResource(config_name, res_name)

   243

   244

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

   245

        """

   246

        Create a new project in an empty folder

   247

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

   248

        @param PLCParams: properties of the PLCOpen program created

   249

        """

   250

        # Verify that chosen folder is empty

   251

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

   252

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

   253

   254

        # Create PLCOpen program

   255

        self.CreateNewProject(

   256

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

   257

             "productName": _("Unnamed"),

   258

             "productVersion": "1",

   259

             "companyName": _("Unknown"),

   260

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

   261

        self.AddProjectDefaultConfiguration()

   262

   263

        # Change XSD into class members

   264

        self._AddParamsMembers()

   265

        self.Children = {}

   266

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

   267

        self.ProjectPath = ProjectPath

   268

        self._setBuildPath(BuildPath)

   269

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

   270

        self.RefreshConfNodesBlockLists()

   271

        # this will create files base XML files

   272

        self.SaveProject()

   273

        return None

   274

   275

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

   276

        """

   277

        Load a project contained in a folder

   278

        @param ProjectPath: path of the project folder

   279

        """

   280

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

   281

            ProjectPath = os.path.dirname(ProjectPath)

   282

		# Verify that project contains a PLCOpen program

   283

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

   284

        if not os.path.isfile(plc_file):

   285

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

   286

        # Load PLCOpen file

   287

        result = self.OpenXMLFile(plc_file)

   288

        if result:

   289

            return result

   290

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

   291

            self.AddProjectDefaultConfiguration()

   292

        # Change XSD into class members

   293

        self._AddParamsMembers()

   294

        self.Children = {}

   295

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

   296

        self.ProjectPath = ProjectPath

   297

        self._setBuildPath(BuildPath)

   298

        # If dir have already be made, and file exist

   299

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

   300

            #Load the confnode.xml file into parameters members

   301

            result = self.LoadXMLParams()

   302

            if result:

   303

                return result

   304

            #Load and init all the children

   305

            self.LoadChildren()

   306

        self.RefreshConfNodesBlockLists()

   307

   308

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

   309

            self.EnableMethod("_Clean", True)

   310

   311

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

   312

            self.ShowMethod("_showIECcode", True)

   313

   314

        return None

   315

   316

    def RecursiveConfNodeInfos(self, confnode):

   317

        values = []

   318

        for CTNChild in confnode.IECSortedChildren():

   319

            values.append(

   320

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

   321

                                     CTNChild.CTNName()), 

   322

                 "type": ITEM_CONFNODE, 

   323

                 "confnode": CTNChild,

   324

                 "icon": CTNChild.GetIconName(),

   325

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

   326

        return values

   327

   328

    def GetProjectInfos(self):

   329

        infos = PLCControler.GetProjectInfos(self)

   330

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

   331

        resources = None

   332

        for config_infos in configurations["values"]:

   333

            if resources is None:

   334

                resources = config_infos["values"][0]

   335

            else:

   336

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

   337

        if resources is not None:

   338

            infos["values"].append(resources)

   339

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

   340

        return infos

   341

   342

    def CloseProject(self):

   343

        self.ClearChildren()

   344

        self.ResetAppFrame(None)

   345

   346

    def SaveProject(self):

   347

        if self.CheckProjectPathPerm(False):

   348

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

   349

            result = self.CTNRequestSave()

   350

            if result:

   351

                self.logger.write_error(result)

   352

   353

    def SaveProjectAs(self, dosave=True):

   354

        # Ask user to choose a path with write permissions

   355

        if wx.Platform == '__WXMSW__':

   356

            path = os.getenv("USERPROFILE")

   357

        else:

   358

            path = os.getenv("HOME")

   359

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

   360

        answer = dirdialog.ShowModal()

   361

        dirdialog.Destroy()

   362

        if answer == wx.ID_OK:

   363

            newprojectpath = dirdialog.GetPath()

   364

            if os.path.isdir(newprojectpath):

   365

                self.ProjectPath = newprojectpath

   366

                if dosave:

   367

                    self.SaveProject()

   368

                self._setBuildPath(self.BuildPath)

   369

                return True

   370

        return False

   371

   372

    def GetLibrariesTypes(self):

   373

        self.LoadLibraries()

   374

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

   375

   376

    def GetLibrariesSTCode(self):

   377

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

   378

   379

    def GetLibrariesCCode(self, buildpath):

   380

        if len(self.Libraries)==0:

   381

            return [],[],()

   382

        self.GetIECProgramsAndVariables()

   383

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

   384

        LocatedCCodeAndFlags=[]

   385

        Extras=[]

   386

        for lib in self.Libraries:

   387

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

   388

            LocatedCCodeAndFlags.append(res[:2])

   389

            if len(res)>2:

   390

                Extras.append(res[2:])

   391

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

   392

   393

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   394

    def RefreshConfNodesBlockLists(self):

   395

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

   396

            self.ClearConfNodeTypes()

   397

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   398

        if self.AppFrame is not None:

   399

            self.AppFrame.RefreshLibraryPanel()

   400

            self.AppFrame.RefreshEditor()

   401

   402

    # Update a PLCOpenEditor Pou variable location

   403

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   404

        self.Project.updateElementAddress(old_leading, new_leading)

   405

        self.BufferProject()

   406

        if self.AppFrame is not None:

   407

            self.AppFrame.RefreshTitle()

   408

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   409

            self.AppFrame.RefreshFileMenu()

   410

            self.AppFrame.RefreshEditMenu()

   411

            wx.CallAfter(self.AppFrame.RefreshEditor)

   412

   413

    def GetVariableLocationTree(self):

   414

        '''

   415

        This function is meant to be overridden by confnodes.

   416

   417

        It should returns an list of dictionaries

   418

   419

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

   420

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

   421

        '''

   422

        children = []

   423

        for child in self.IECSortedChildren():

   424

            children.append(child.GetVariableLocationTree())

   425

        return children

   426

   427

    def ConfNodePath(self):

   428

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

   429

   430

    def CTNPath(self, CTNName=None):

   431

        return self.ProjectPath

   432

   433

    def ConfNodeXmlFilePath(self, CTNName=None):

   434

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

   435

   436

    def ParentsTypesFactory(self):

   437

        return self.ConfNodeTypesFactory()

   438

   439

    def _setBuildPath(self, buildpath):

   440

        if CheckPathPerm(buildpath):

   441

            self.BuildPath = buildpath

   442

        else:

   443

            self.BuildPath = None

   444

        self.BuildPath = buildpath

   445

        self.DefaultBuildPath = None

   446

        if self._builder is not None:

   447

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

   448

   449

    def _getBuildPath(self):

   450

        # BuildPath is defined by user

   451

        if self.BuildPath is not None:

   452

            return self.BuildPath

   453

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

   454

        if self.DefaultBuildPath is not None:

   455

            return self.DefaultBuildPath

   456

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

   457

        if CheckPathPerm(self.ProjectPath):

   458

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

   459

        # Create a build path in temp folder

   460

        else:

   461

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

   462

   463

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

   464

            os.makedirs(self.DefaultBuildPath)

   465

        return self.DefaultBuildPath

   466

   467

    def _getExtraFilesPath(self):

   468

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

   469

   470

    def _getIECcodepath(self):

   471

        # define name for IEC code file

   472

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

   473

   474

    def _getIECgeneratedcodepath(self):

   475

        # define name for IEC generated code file

   476

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

   477

   478

    def _getIECrawcodepath(self):

   479

        # define name for IEC raw code file

   480

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

   481

   482

    def GetLocations(self):

   483

        locations = []