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

    25

from dialogs import DiscoveryDialog

    26

from PLCControler import PLCControler

    27

from plcopen.structures import IEC_KEYWORDS

    28

from targets.typemapping import DebugTypesSize

    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

        # 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

            # Timer to pull PLC status

   140

            ID_STATUSTIMER = wx.NewId()

   141

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

   142

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

   143

   144

            self.RefreshConfNodesBlockLists()

   145

   146

    def ResetAppFrame(self, logger):

   147

        if self.AppFrame is not None:

   148

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

   149

            self.StatusTimer = None

   150

            self.AppFrame = None

   151

   152

        self.logger = logger

   153

   154

    def CTNName(self):

   155

        return "Project"

   156

   157

    def CTNTestModified(self):

   158

         return self.ChangesToSave or not self.ProjectIsSaved()

   159

   160

    def CTNFullName(self):

   161

        return ""

   162

   163

    def GetCTRoot(self):

   164

        return self

   165

   166

    def GetIECLibPath(self):

   167

        return self.ieclib_path

   168

   169

    def GetIEC2cPath(self):

   170

        return self.iec2c_path

   171

   172

    def GetCurrentLocation(self):

   173

        return ()

   174

   175

    def GetCurrentName(self):

   176

        return ""

   177

   178

    def _GetCurrentName(self):

   179

        return ""

   180

   181

    def GetProjectPath(self):

   182

        return self.ProjectPath

   183

   184

    def GetProjectName(self):

   185

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

   186

   187

    def GetIconName(self):

   188

        return "PROJECT"

   189

   190

    def GetDefaultTargetName(self):

   191

        if wx.Platform == '__WXMSW__':

   192

            return "Win32"

   193

        else:

   194

            return "Linux"

   195

   196

    def GetTarget(self):

   197

        target = self.BeremizRoot.getTargetType()

   198

        if target.getcontent() is None:

   199

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

   200

            target_name = self.GetDefaultTargetName()

   201

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

   202

        return target

   203

   204

    def GetParamsAttributes(self, path = None):

   205

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   206

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

   207

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

   208

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

   209

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

   210

        return params

   211

   212

    def SetParamsAttribute(self, path, value):

   213

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

   214

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

   215

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   216

   217

    # helper func to check project path write permission

   218

    def CheckProjectPathPerm(self, dosave=True):

   219

        if CheckPathPerm(self.ProjectPath):

   220

            return True

   221

        dialog = wx.MessageDialog(self.AppFrame, 

   222

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

   223

                    _('Error'), 

   224

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

   225

        answer = dialog.ShowModal()

   226

        dialog.Destroy()

   227

        if answer == wx.ID_YES:

   228

            if self.SaveProjectAs():

   229

                self.AppFrame.RefreshTitle()

   230

                self.AppFrame.RefreshFileMenu()

   231

                self.AppFrame.RefreshPageTitles()

   232

                return True

   233

        return False

   234

   235

    def _getProjectFilesPath(self):

   236

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

   237

        if not os.path.exists(projectfiles_path):

   238

            os.mkdir(projectfiles_path)

   239

        return projectfiles_path

   240

   241

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

   242

        self.ProjectAddConfiguration(config_name)

   243

        self.ProjectAddConfigurationResource(config_name, res_name)

   244

   245

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

   246

        """

   247

        Create a new project in an empty folder

   248

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

   249

        @param PLCParams: properties of the PLCOpen program created

   250

        """

   251

        # Verify that chosen folder is empty

   252

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

   253

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

   254

   255

        # Create PLCOpen program

   256

        self.CreateNewProject(

   257

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

   258

             "productName": _("Unnamed"),

   259

             "productVersion": "1",

   260

             "companyName": _("Unknown"),

   261

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

   262

        self.AddProjectDefaultConfiguration()

   263

   264

        # Change XSD into class members

   265

        self._AddParamsMembers()

   266

        self.Children = {}

   267

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

   268

        self.ProjectPath = ProjectPath

   269

        self._setBuildPath(BuildPath)

   270

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

   271

        self.RefreshConfNodesBlockLists()

   272

        # this will create files base XML files

   273

        self.SaveProject()

   274

        return None

   275

   276

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

   277

        """

   278

        Load a project contained in a folder

   279

        @param ProjectPath: path of the project folder

   280

        """

   281

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

   282

            ProjectPath = os.path.dirname(ProjectPath)

   283

		# Verify that project contains a PLCOpen program

   284

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

   285

        if not os.path.isfile(plc_file):

   286

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

   287

        # Load PLCOpen file

   288

        result = self.OpenXMLFile(plc_file)

   289

        if result:

   290

            return result

   291

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

   292

            self.AddProjectDefaultConfiguration()

   293

        # Change XSD into class members

   294

        self._AddParamsMembers()

   295

        self.Children = {}

   296

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

   297

        self.ProjectPath = ProjectPath

   298

        self._setBuildPath(BuildPath)

   299

        # If dir have already be made, and file exist

   300

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

   301

            #Load the confnode.xml file into parameters members

   302

            result = self.LoadXMLParams()

   303

            if result:

   304

                return result

   305

            #Load and init all the children

   306

            self.LoadChildren()

   307

        self.RefreshConfNodesBlockLists()

   308

   309

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

   310

            self.EnableMethod("_Clean", True)

   311

   312

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

   313

            self.ShowMethod("_showIECcode", True)

   314

   315

        return None

   316

   317

    def RecursiveConfNodeInfos(self, confnode):

   318

        values = []

   319

        for CTNChild in confnode.IECSortedChildren():

   320

            values.append(

   321

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

   322

                                     CTNChild.CTNName()), 

   323

                 "type": ITEM_CONFNODE, 

   324

                 "confnode": CTNChild,

   325

                 "icon": CTNChild.GetIconName(),

   326

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

   327

        return values

   328

   329

    def GetProjectInfos(self):

   330

        infos = PLCControler.GetProjectInfos(self)

   331

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

   332

        resources = None

   333

        for config_infos in configurations["values"]:

   334

            if resources is None:

   335

                resources = config_infos["values"][0]

   336

            else:

   337

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

   338

        if resources is not None:

   339

            infos["values"].append(resources)

   340

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

   341

        return infos

   342

   343

    def CloseProject(self):

   344

        self.ClearChildren()

   345

        self.ResetAppFrame(None)

   346

   347

    def SaveProject(self):

   348

        if self.CheckProjectPathPerm(False):

   349

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

   350

            result = self.CTNRequestSave()

   351

            if result:

   352

                self.logger.write_error(result)

   353

   354

    def SaveProjectAs(self, dosave=True):

   355

        # Ask user to choose a path with write permissions

   356

        if wx.Platform == '__WXMSW__':

   357

            path = os.getenv("USERPROFILE")

   358

        else:

   359

            path = os.getenv("HOME")

   360

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

   361

        answer = dirdialog.ShowModal()

   362

        dirdialog.Destroy()

   363

        if answer == wx.ID_OK:

   364

            newprojectpath = dirdialog.GetPath()

   365

            if os.path.isdir(newprojectpath):

   366

                self.ProjectPath = newprojectpath

   367

                if dosave:

   368

                    self.SaveProject()

   369

                self._setBuildPath(self.BuildPath)

   370

                return True

   371

        return False

   372

   373

    def GetLibrariesTypes(self):

   374

        self.LoadLibraries()

   375

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

   376

   377

    def GetLibrariesSTCode(self):

   378

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

   379

   380

    def GetLibrariesCCode(self, buildpath):

   381

        if len(self.Libraries)==0:

   382

            return [],[],()

   383

        self.GetIECProgramsAndVariables()

   384

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

   385

        LocatedCCodeAndFlags=[]

   386

        Extras=[]

   387

        for lib in self.Libraries:

   388

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

   389

            LocatedCCodeAndFlags.append(res[:2])

   390

            if len(res)>2:

   391

                Extras.extend(res[2:])

   392

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

   393

   394

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   395

    def RefreshConfNodesBlockLists(self):

   396

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

   397

            self.ClearConfNodeTypes()

   398

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   399

        if self.AppFrame is not None:

   400

            self.AppFrame.RefreshLibraryPanel()

   401

            self.AppFrame.RefreshEditor()

   402

   403

    # Update a PLCOpenEditor Pou variable location

   404

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   405

        self.Project.updateElementAddress(old_leading, new_leading)

   406

        self.BufferProject()

   407

        if self.AppFrame is not None:

   408

            self.AppFrame.RefreshTitle()

   409

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   410

            self.AppFrame.RefreshFileMenu()

   411

            self.AppFrame.RefreshEditMenu()

   412

            wx.CallAfter(self.AppFrame.RefreshEditor)

   413

   414

    def GetVariableLocationTree(self):

   415

        '''

   416

        This function is meant to be overridden by confnodes.

   417

   418

        It should returns an list of dictionaries

   419

   420

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

   421

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

   422

        '''

   423

        children = []

   424

        for child in self.IECSortedChildren():

   425

            children.append(child.GetVariableLocationTree())

   426

        return children

   427

   428

    def ConfNodePath(self):

   429

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

   430

   431

    def CTNPath(self, CTNName=None):

   432

        return self.ProjectPath

   433

   434

    def ConfNodeXmlFilePath(self, CTNName=None):

   435

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

   436

   437

    def ParentsTypesFactory(self):

   438

        return self.ConfNodeTypesFactory()

   439

   440

    def _setBuildPath(self, buildpath):

   441

        if CheckPathPerm(buildpath):

   442

            self.BuildPath = buildpath

   443

        else:

   444

            self.BuildPath = None

   445

        self.BuildPath = buildpath

   446

        self.DefaultBuildPath = None

   447

        if self._builder is not None:

   448

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

   449

   450

    def _getBuildPath(self):

   451

        # BuildPath is defined by user

   452

        if self.BuildPath is not None:

   453

            return self.BuildPath

   454

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

   455

        if self.DefaultBuildPath is not None:

   456

            return self.DefaultBuildPath

   457

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

   458

        if CheckPathPerm(self.ProjectPath):

   459

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

   460

        # Create a build path in temp folder

   461

        else:

   462

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

   463

   464

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

   465

            os.makedirs(self.DefaultBuildPath)

   466

        return self.DefaultBuildPath

   467

   468

    def _getExtraFilesPath(self):

   469

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

   470

   471

    def _getIECcodepath(self):

   472

        # define name for IEC code file

   473

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

   474

   475

    def _getIECgeneratedcodepath(self):

   476

        # define name for IEC generated code file

   477

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

   478

   479

    def _getIECrawcodepath(self):

   480

        # define name for IEC raw code file

   481

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

   482

   483

    def GetLocations(self):