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

    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:

   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):

   238

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

   239

        if not os.path.exists(projectfiles_path):

   240

            os.mkdir(projectfiles_path)

   241

        return projectfiles_path

   242

   243

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

   244

        self.ProjectAddConfiguration(config_name)

   245

        self.ProjectAddConfigurationResource(config_name, res_name)

   246

   247

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

   248

        """

   249

        Create a new project in an empty folder

   250

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

   251

        @param PLCParams: properties of the PLCOpen program created

   252

        """

   253

        # Verify that chosen folder is empty

   254

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

   255

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

   256

   257

        # Create PLCOpen program

   258

        self.CreateNewProject(

   259

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

   260

             "productName": _("Unnamed"),

   261

             "productVersion": "1",

   262

             "companyName": _("Unknown"),

   263

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

   264

        self.AddProjectDefaultConfiguration()

   265

   266

        # Change XSD into class members

   267

        self._AddParamsMembers()

   268

        self.Children = {}

   269

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

   270

        self.ProjectPath = ProjectPath

   271

        self._setBuildPath(BuildPath)

   272

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

   273

        self.RefreshConfNodesBlockLists()

   274

        # this will create files base XML files

   275

        self.SaveProject()

   276

        return None

   277

   278

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

   279

        """

   280

        Load a project contained in a folder

   281

        @param ProjectPath: path of the project folder

   282

        """

   283

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

   284

            ProjectPath = os.path.dirname(ProjectPath)

   286

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

   287

        if not os.path.isfile(plc_file):

   288

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

   289

        # Load PLCOpen file

   290

        result = self.OpenXMLFile(plc_file)

   291

        if result:

   292

            return result

   293

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

   294

            self.AddProjectDefaultConfiguration()

   295

        # Change XSD into class members

   296

        self._AddParamsMembers()

   297

        self.Children = {}

   298

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

   299

        self.ProjectPath = ProjectPath

   300

        self._setBuildPath(BuildPath)

   301

        # If dir have already be made, and file exist

   302

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

   303

            #Load the confnode.xml file into parameters members

   304

            result = self.LoadXMLParams()

   305

            if result:

   306

                return result

   307

            #Load and init all the children

   308

            self.LoadChildren()

   309

        self.RefreshConfNodesBlockLists()

   310

   311

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

   312

            self.EnableMethod("_Clean", True)

   313

   314

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

   315

            self.ShowMethod("_showIECcode", True)

   316

   317

        return None

   318

   319

    def RecursiveConfNodeInfos(self, confnode):

   320

        values = []

   321

        for CTNChild in confnode.IECSortedChildren():

   322

            values.append(

   323

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

   324

                                     CTNChild.CTNName()), 

   325

                 "type": ITEM_CONFNODE, 

   326

                 "confnode": CTNChild,

   327

                 "icon": CTNChild.GetIconName(),

   328

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

   329

        return values

   330

   331

    def GetProjectInfos(self):

   332

        infos = PLCControler.GetProjectInfos(self)

   333

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

   334

        resources = None

   335

        for config_infos in configurations["values"]:

   336

            if resources is None:

   337

                resources = config_infos["values"][0]

   338

            else:

   339

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

   340

        if resources is not None:

   341

            infos["values"].append(resources)

   342

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

   343

        return infos

   344

   345

    def CloseProject(self):

   346

        self.ClearChildren()

   347

        self.ResetAppFrame(None)

   348

   349

    def SaveProject(self):

   350

        if self.CheckProjectPathPerm(False):

   351

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

   352

            result = self.CTNRequestSave()

   353

            if result:

   354

                self.logger.write_error(result)

   355

   356

    def SaveProjectAs(self, dosave=True):

   357

        # Ask user to choose a path with write permissions

   358

        if wx.Platform == '__WXMSW__':

   359

            path = os.getenv("USERPROFILE")

   360

        else:

   361

            path = os.getenv("HOME")

   362

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

   363

        answer = dirdialog.ShowModal()

   364

        dirdialog.Destroy()

   365

        if answer == wx.ID_OK:

   366

            newprojectpath = dirdialog.GetPath()

   367

            if os.path.isdir(newprojectpath):

   368

                self.ProjectPath = newprojectpath

   369

                if dosave:

   370

                    self.SaveProject()

   371

                self._setBuildPath(self.BuildPath)

   372

                return True

   373

        return False

   374

   375

    def GetLibrariesTypes(self):

   376

        self.LoadLibraries()

   377

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

   378

   379

    def GetLibrariesSTCode(self):

   380

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

   381

   382

    def GetLibrariesCCode(self, buildpath):

   383

        if len(self.Libraries)==0:

   384

            return [],[],()

   385

        self.GetIECProgramsAndVariables()

   386

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

   387

        LocatedCCodeAndFlags=[]

   388

        Extras=[]

   389

        for lib in self.Libraries:

   390

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

   391

            LocatedCCodeAndFlags.append(res[:2])

   392

            if len(res)>2:

   393

                Extras.extend(res[2:])

   394

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

   395

   396

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   397

    def RefreshConfNodesBlockLists(self):

   398

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

   399

            self.ClearConfNodeTypes()

   400

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   401

        if self.AppFrame is not None:

   402

            self.AppFrame.RefreshLibraryPanel()

   403

            self.AppFrame.RefreshEditor()

   404

   405

    # Update a PLCOpenEditor Pou variable location

   406

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   407

        self.Project.updateElementAddress(old_leading, new_leading)

   408

        self.BufferProject()

   409

        if self.AppFrame is not None:

   410

            self.AppFrame.RefreshTitle()

   411

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   412

            self.AppFrame.RefreshFileMenu()

   413

            self.AppFrame.RefreshEditMenu()

   414

            wx.CallAfter(self.AppFrame.RefreshEditor)

   415

   416

    def GetVariableLocationTree(self):

   417

        '''

   418

        This function is meant to be overridden by confnodes.

   419

   420

        It should returns an list of dictionaries

   421

   422

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

   423

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

   424

        '''

   425

        children = []

   426

        for child in self.IECSortedChildren():

   427

            children.append(child.GetVariableLocationTree())

   428

        return children

   429

   430

    def ConfNodePath(self):

   431

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

   432

   433

    def CTNPath(self, CTNName=None):

   434

        return self.ProjectPath

   435

   436

    def ConfNodeXmlFilePath(self, CTNName=None):

   437

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

   438

   439

    def ParentsTypesFactory(self):

   440

        return self.ConfNodeTypesFactory()

   441

   442

    def _setBuildPath(self, buildpath):

   443

        if CheckPathPerm(buildpath):

   444

            self.BuildPath = buildpath

   445

        else:

   446

            self.BuildPath = None

   447

        self.BuildPath = buildpath

   448

        self.DefaultBuildPath = None

   449

        if self._builder is not None:

   450

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

   451

   452

    def _getBuildPath(self):

   453

        # BuildPath is defined by user

   454

        if self.BuildPath is not None:

   455

            return self.BuildPath

   456

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

   457

        if self.DefaultBuildPath is not None:

   458

            return self.DefaultBuildPath

   459

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

   460

        if CheckPathPerm(self.ProjectPath):

   461

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

   462

        # Create a build path in temp folder

   463

        else:

   464

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

   465

   466

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

   467

            os.makedirs(self.DefaultBuildPath)

   468

        return self.DefaultBuildPath

   469

   470

    def _getExtraFilesPath(self):

   471

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

   472

   473

    def _getIECcodepath(self):

   474

        # define name for IEC code file

   475

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

   476

   477

    def _getIECgeneratedcodepath(self):

   478

        # define name for IEC generated code file

   479

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

   480

   481

    def _getIECrawcodepath(self):

   482

        # define name for IEC raw code file

   483

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