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.FileManagementPanel import FileManagementPanel

    21

from PLCControler import PLCControler

    22

from TextViewer import TextViewer

    23

from plcopen.structures import IEC_KEYWORDS

    24

from targets.typemapping import DebugTypesSize

    25

from util.discovery import DiscoveryDialog

    26

from ConfigTreeNode import ConfigTreeNode

    27

from ProjectNodeEditor import ProjectNodeEditor

    28

from utils.BitmapLibrary import GetBitmap

    29

    30

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

    31

    32

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

    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 NewProject(self, ProjectPath, BuildPath=None):

   241

        """

   242

        Create a new project in an empty folder

   243

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

   244

        @param PLCParams: properties of the PLCOpen program created

   245

        """

   246

        # Verify that chosen folder is empty

   247

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

   248

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

   249

   250

        # Create PLCOpen program

   251

        self.CreateNewProject(

   252

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

   253

             "productName": _("Unnamed"),

   254

             "productVersion": _("1"),

   255

             "companyName": _("Unknown"),

   256

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

   257

        self.ProjectAddConfiguration("config")

   258

        self.ProjectAddConfigurationResource("config", "resource1")

   259

   260

        # Change XSD into class members

   261

        self._AddParamsMembers()

   262

        self.Children = {}

   263

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

   264

        self.ProjectPath = ProjectPath

   265

        self._setBuildPath(BuildPath)

   266

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

   267

        self.RefreshConfNodesBlockLists()

   268

        # this will create files base XML files

   269

        self.SaveProject()

   270

        return None

   271

   272

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

   273

        """

   274

        Load a project contained in a folder

   275

        @param ProjectPath: path of the project folder

   276

        """

   277

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

   278

            ProjectPath = os.path.dirname(ProjectPath)

   279

		# Verify that project contains a PLCOpen program

   280

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

   281

        if not os.path.isfile(plc_file):

   282

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

   283

        # Load PLCOpen file

   284

        result = self.OpenXMLFile(plc_file)

   285

        if result:

   286

            return result

   287

        # Change XSD into class members

   288

        self._AddParamsMembers()

   289

        self.Children = {}

   290

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

   291

        self.ProjectPath = ProjectPath

   292

        self._setBuildPath(BuildPath)

   293

        # If dir have already be made, and file exist

   294

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

   295

            #Load the confnode.xml file into parameters members

   296

            result = self.LoadXMLParams()

   297

            if result:

   298

                return result

   299

            #Load and init all the children

   300

            self.LoadChildren()

   301

        self.RefreshConfNodesBlockLists()

   302

   303

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

   304

            self.EnableMethod("_Clean", True)

   305

   306

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

   307

            self.ShowMethod("_showIECcode", True)

   308

   309

        return None

   310

   311

    def RecursiveConfNodeInfos(self, confnode):

   312

        values = []

   313

        for CTNChild in confnode.IECSortedChildren():

   314

            values.append(

   315

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

   316

                                     CTNChild.CTNName()), 

   317

                 "type": ITEM_CONFNODE, 

   318

                 "confnode": CTNChild,

   319

                 "icon": CTNChild.GetIconName(),

   320

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

   321

        return values

   322

   323

    def GetProjectInfos(self):

   324

        infos = PLCControler.GetProjectInfos(self)

   325

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

   326

        resources = None

   327

        for config_infos in configurations["values"]:

   328

            if resources is None:

   329

                resources = config_infos["values"][0]

   330

            else:

   331

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

   332

        if resources is not None:

   333

            infos["values"].append(resources)

   334

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

   335

        return infos

   336

   337

    def CloseProject(self):

   338

        self.ClearChildren()

   339

        self.ResetAppFrame(None)

   340

   341

    def SaveProject(self):

   342

        if self.CheckProjectPathPerm(False):

   343

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

   344

            result = self.CTNRequestSave()

   345

            if result:

   346

                self.logger.write_error(result)

   347

   348

    def SaveProjectAs(self, dosave=True):

   349

        # Ask user to choose a path with write permissions

   350

        if wx.Platform == '__WXMSW__':

   351

            path = os.getenv("USERPROFILE")

   352

        else:

   353

            path = os.getenv("HOME")

   354

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

   355

        answer = dirdialog.ShowModal()

   356

        dirdialog.Destroy()

   357

        if answer == wx.ID_OK:

   358

            newprojectpath = dirdialog.GetPath()

   359

            if os.path.isdir(newprojectpath):

   360

                self.ProjectPath = newprojectpath

   361

                if dosave:

   362

                    self.SaveProject()

   363

                self._setBuildPath(self.BuildPath)

   364

                return True

   365

        return False

   366

   367

    def GetLibrariesTypes(self):

   368

        self.LoadLibraries()

   369

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

   370

   371

    def GetLibrariesSTCode(self):

   372

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

   373

   374

    def GetLibrariesCCode(self, buildpath):

   375

        if len(self.Libraries)==0:

   376

            return [],[],()

   377

        self.GetIECProgramsAndVariables()

   378

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

   379

        LocatedCCodeAndFlags=[]

   380

        Extras=[]

   381

        for lib in self.Libraries:

   382

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

   383

            LocatedCCodeAndFlags.append(res[:2])

   384

            if len(res)>2:

   385

                Extras.append(res[2:])

   386

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

   387

   388

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   389

    def RefreshConfNodesBlockLists(self):

   390

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

   391

            self.ClearConfNodeTypes()

   392

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   393

        if self.AppFrame is not None:

   394

            self.AppFrame.RefreshLibraryPanel()

   395

            self.AppFrame.RefreshEditor()

   396

   397

    # Update a PLCOpenEditor Pou variable location

   398

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   399

        self.Project.updateElementAddress(old_leading, new_leading)

   400

        self.BufferProject()

   401

        if self.AppFrame is not None:

   402

            self.AppFrame.RefreshTitle()

   403

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   404

            self.AppFrame.RefreshFileMenu()

   405

            self.AppFrame.RefreshEditMenu()

   406

            self.AppFrame.RefreshEditor()

   407

   408

    def GetVariableLocationTree(self):

   409

        '''

   410

        This function is meant to be overridden by confnodes.

   411

   412

        It should returns an list of dictionaries

   413

   414

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

   415

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

   416

        '''

   417

        children = []

   418

        for child in self.IECSortedChildren():

   419

            children.append(child.GetVariableLocationTree())

   420

        return children

   421

   422

    def ConfNodePath(self):

   423

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

   424

   425

    def CTNPath(self, CTNName=None):

   426

        return self.ProjectPath

   427

   428

    def ConfNodeXmlFilePath(self, CTNName=None):

   429

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

   430

   431

    def ParentsTypesFactory(self):

   432

        return self.ConfNodeTypesFactory()

   433

   434

    def _setBuildPath(self, buildpath):

   435

        if CheckPathPerm(buildpath):

   436

            self.BuildPath = buildpath

   437

        else:

   438

            self.BuildPath = None

   439

        self.BuildPath = buildpath

   440

        self.DefaultBuildPath = None

   441

        if self._builder is not None:

   442

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

   443

   444

    def _getBuildPath(self):

   445

        # BuildPath is defined by user

   446

        if self.BuildPath is not None:

   447

            return self.BuildPath

   448

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

   449

        if self.DefaultBuildPath is not None:

   450

            return self.DefaultBuildPath

   451

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

   452

        if CheckPathPerm(self.ProjectPath):

   453

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

   454

        # Create a build path in temp folder

   455

        else:

   456

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

   457

   458

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

   459

            os.makedirs(self.DefaultBuildPath)

   460

        return self.DefaultBuildPath

   461

   462

    def _getExtraFilesPath(self):

   463

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

   464

   465

    def _getIECcodepath(self):

   466

        # define name for IEC code file

   467

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

   468

   469

    def _getIECgeneratedcodepath(self):

   470

        # define name for IEC generated code file

   471

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

   472

   473

    def _getIECrawcodepath(self):

   474

        # define name for IEC raw code file

   475

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

   476

   477

    def GetLocations(self):

   478

        locations = []

   479

        filepath = os.path.join(self._getBuildPath(),"LOCATED_VARIABLES.h")

   480

        if os.path.isfile(filepath):

   481

            # IEC2C compiler generate a list of located variables : LOCATED_VARIABLES.h

   482

            location_file = open(os.path.join(self._getBuildPath(),"LOCATED_VARIABLES.h"))

   483

            # each line of LOCATED_VARIABLES.h declares a located variable