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 opjimg, CheckPathPerm, GetClassImporter

    18

from util.MiniTextControler import MiniTextControler

    19

from util.ProcessLogger import ProcessLogger

    20

from PLCControler import PLCControler

    21

from PLCOpenEditor import CWD

    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

    29

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

    30

    31

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

    32

    33

DEBUG_RETRIES_WARN = 3

    34

DEBUG_RETRIES_REREGISTER = 4

    35

    36

ITEM_CONFNODE = 25

    37

    38

class ProjectController(ConfigTreeNode, PLCControler):

    39

    """

    40

    This class define Root object of the confnode tree. 

    41

    It is responsible of :

    42

    - Managing project directory

    43

    - Building project

    44

    - Handling PLCOpenEditor controler and view

    45

    - Loading user confnodes and instanciante them as children

    46

    - ...

    47

    48

    """

    49

    50

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

    51

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

    52

    53

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

    54

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

    55

      <xsd:element name="BeremizRoot">

    56

        <xsd:complexType>

    57

          <xsd:sequence>

    58

            <xsd:element name="TargetType">

    59

              <xsd:complexType>

    60

                <xsd:choice minOccurs="0">

    61

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

    62

                </xsd:choice>

    63

              </xsd:complexType>

    64

            </xsd:element>

    65

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

    66

              <xsd:complexType>

    67

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

    68

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

    69

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

    70

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

    71

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

    72

            </xsd:element>

    73

          </xsd:sequence>

    74

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

    75

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

    76

        </xsd:complexType>

    77

      </xsd:element>

    78

    </xsd:schema>

    79

    """

    80

    EditorType = ProjectNodeEditor

    81

    82

    def __init__(self, frame, logger):

    83

        PLCControler.__init__(self)

    84

    85

        self.MandatoryParams = None

    86

        self.SetAppFrame(frame, logger)

    87

        self._builder = None

    88

        self._connector = None

    89

    90

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

    91

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

    92

    93

        # Setup debug information

    94

        self.IECdebug_datas = {}

    95

        self.IECdebug_lock = Lock()

    96

    97

        self.DebugTimer=None

    98

        self.ResetIECProgramsAndVariables()

    99

   100

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

   101

        self.ChangesToSave = False

   102

        # root have no parent

   103

        self.CTNParent = None

   104

        # Keep track of the confnode type name

   105

        self.CTNType = "Beremiz"

   106

        self.Children = {}

   107

        self._View = None

   108

        # After __init__ root confnode is not valid

   109

        self.ProjectPath = None

   110

        self._setBuildPath(None)

   111

        self.DebugThread = None

   112

        self.debug_break = False

   113

        self.previous_plcstate = None

   114

        # copy ConfNodeMethods so that it can be later customized

   115

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

   116

   117

    def LoadLibraries(self):

   118

        self.Libraries = []

   119

        TypeStack=[]

   120

        for libname,clsname in features.libraries:

   121

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

   122

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

   123

                TypeStack.append(Lib.GetTypes())

   124

                self.Libraries.append(Lib)

   125

   126

    def __del__(self):

   127

        if self.DebugTimer:

   128

            self.DebugTimer.cancel()

   129

        self.KillDebugThread()

   130

   131

    def SetAppFrame(self, frame, logger):

   132

        self.AppFrame = frame

   133

        self.logger = logger

   134

        self.StatusTimer = None

   135

   136

        if frame is not None:

   137

            # Timer to pull PLC status

   138

            ID_STATUSTIMER = wx.NewId()

   139

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

   140

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

   141

   142

            self.RefreshConfNodesBlockLists()

   143

   144

    def ResetAppFrame(self, logger):

   145

        if self.AppFrame is not None:

   146

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

   147

            self.StatusTimer = None

   148

            self.AppFrame = None

   149

   150

        self.logger = logger

   151

   152

    def CTNName(self):

   153

        return "Project"

   154

   155

    def CTNTestModified(self):

   156

         return self.ChangesToSave or not self.ProjectIsSaved()

   157

   158

    def CTNFullName(self):

   159

        return ""

   160

   161

    def GetCTRoot(self):

   162

        return self

   163

   164

    def GetIECLibPath(self):

   165

        return self.ieclib_path

   166

   167

    def GetIEC2cPath(self):

   168

        return self.iec2c_path

   169

   170

    def GetCurrentLocation(self):

   171

        return ()

   172

   173

    def GetCurrentName(self):

   174

        return ""

   175

   176

    def _GetCurrentName(self):

   177

        return ""

   178

   179

    def GetProjectPath(self):

   180

        return self.ProjectPath

   181

   182

    def GetProjectName(self):

   183

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

   184

   185

    def GetIconPath(self):

   186

        return os.path.join(CWD, "Images", "PROJECT.png")

   187

   188

    def GetDefaultTargetName(self):

   189

        if wx.Platform == '__WXMSW__':

   190

            return "Win32"

   191

        else:

   192

            return "Linux"

   193

   194

    def GetTarget(self):

   195

        target = self.BeremizRoot.getTargetType()

   196

        if target.getcontent() is None:

   197

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

   198

            target_name = self.GetDefaultTargetName()

   199

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

   200

        return target

   201

   202

    def GetParamsAttributes(self, path = None):

   203

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   204

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

   205

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

   206

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

   207

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

   208

        return params

   209

   210

    def SetParamsAttribute(self, path, value):

   211

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

   212

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

   213

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   214

   215

    # helper func to check project path write permission

   216

    def CheckProjectPathPerm(self, dosave=True):

   217

        if CheckPathPerm(self.ProjectPath):

   218

            return True

   219

        dialog = wx.MessageDialog(self.AppFrame, 

   220

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

   221

                    _('Error'), 

   222

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

   223

        answer = dialog.ShowModal()

   224

        dialog.Destroy()

   225

        if answer == wx.ID_YES:

   226

            if self.SaveProjectAs():

   227

                self.AppFrame.RefreshTitle()

   228

                self.AppFrame.RefreshFileMenu()

   229

                self.AppFrame.RefreshPageTitles()

   230

                return True

   231

        return False

   232

   233

    def _getProjectFilesPath(self):

   234

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

   235

        if not os.path.exists(projectfiles_path):

   236

            os.mkdir(projectfiles_path)

   237

        return projectfiles_path

   238

   239

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

   240

        """

   241

        Create a new project in an empty folder

   242

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

   243

        @param PLCParams: properties of the PLCOpen program created

   244

        """

   245

        # Verify that chosen folder is empty

   246

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

   247

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

   248

   249

        # Create PLCOpen program

   250

        self.CreateNewProject(

   251

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

   252

             "productName": _("Unnamed"),

   253

             "productVersion": _("1"),

   254

             "companyName": _("Unknown"),

   255

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

   256

        self.ProjectAddConfiguration("config")

   257

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

   258

   259

        # Change XSD into class members

   260

        self._AddParamsMembers()

   261

        self.Children = {}

   262

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

   263

        self.ProjectPath = ProjectPath

   264

        self._setBuildPath(BuildPath)

   265

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

   266

        self.RefreshConfNodesBlockLists()

   267

        # this will create files base XML files

   268

        self.SaveProject()

   269

        return None

   270

   271

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

   272

        """

   273

        Load a project contained in a folder

   274

        @param ProjectPath: path of the project folder

   275

        """

   276

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

   277

            ProjectPath = os.path.dirname(ProjectPath)

   278

		# Verify that project contains a PLCOpen program

   279

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

   280

        if not os.path.isfile(plc_file):

   281

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

   282

        # Load PLCOpen file

   283

        result = self.OpenXMLFile(plc_file)

   284

        if result:

   285

            return result

   286

        # Change XSD into class members

   287

        self._AddParamsMembers()

   288

        self.Children = {}

   289

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

   290

        self.ProjectPath = ProjectPath

   291

        self._setBuildPath(BuildPath)

   292

        # If dir have already be made, and file exist

   293

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

   294

            #Load the confnode.xml file into parameters members

   295

            result = self.LoadXMLParams()

   296

            if result:

   297

                return result

   298

            #Load and init all the children

   299

            self.LoadChildren()

   300

        self.RefreshConfNodesBlockLists()

   301

   302

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

   303

            self.EnableMethod("_Clean", True)

   304

   305

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

   306

            self.ShowMethod("_showIECcode", True)

   307

   308

        return None

   309

   310

    def RecursiveConfNodeInfos(self, confnode):

   311

        values = []

   312

        for CTNChild in confnode.IECSortedChildren():

   313

            values.append(

   314

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

   315

                                     CTNChild.CTNName()), 

   316

                 "type": ITEM_CONFNODE, 

   317

                 "confnode": CTNChild,

   318

                 "icon": CTNChild.GetIconPath(),

   319

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

   320

        return values

   321

   322

    def GetProjectInfos(self):

   323

        infos = PLCControler.GetProjectInfos(self)

   324

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

   325

        resources = None

   326

        for config_infos in configurations["values"]:

   327

            if resources is None:

   328

                resources = config_infos["values"][0]

   329

            else:

   330

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

   331

        if resources is not None:

   332

            infos["values"].append(resources)

   333

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

   334

        return infos

   335

   336

    def CloseProject(self):

   337

        self.ClearChildren()

   338

        self.ResetAppFrame(None)

   339

   340

    def SaveProject(self):

   341

        if self.CheckProjectPathPerm(False):

   342

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

   343

            result = self.CTNRequestSave()

   344

            if result:

   345

                self.logger.write_error(result)

   346

   347

    def SaveProjectAs(self, dosave=True):

   348

        # Ask user to choose a path with write permissions

   349

        if wx.Platform == '__WXMSW__':

   350

            path = os.getenv("USERPROFILE")

   351

        else:

   352

            path = os.getenv("HOME")

   353

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

   354

        answer = dirdialog.ShowModal()

   355

        dirdialog.Destroy()

   356

        if answer == wx.ID_OK:

   357

            newprojectpath = dirdialog.GetPath()

   358

            if os.path.isdir(newprojectpath):

   359

                self.ProjectPath = newprojectpath

   360

                if dosave:

   361

                    self.SaveProject()

   362

                self._setBuildPath(self.BuildPath)

   363

                return True

   364

        return False

   365

   366

    def GetLibrariesTypes(self):

   367

        self.LoadLibraries()

   368

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

   369

   370

    def GetLibrariesSTCode(self):

   371

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

   372

   373

    def GetLibrariesCCode(self, buildpath):

   374

        if len(self.Libraries)==0:

   375

            return [],[],()

   376

        self.GetIECProgramsAndVariables()

   377

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

   378

        LocatedCCodeAndFlags=[]

   379

        Extras=[]

   380

        for lib in self.Libraries:

   381

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

   382

            LocatedCCodeAndFlags.append(res[:2])

   383

            if len(res)>2:

   384

                Extras.append(res[2:])

   385

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

   386

   387

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   388

    def RefreshConfNodesBlockLists(self):

   389

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

   390

            self.ClearConfNodeTypes()

   391

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   392

        if self.AppFrame is not None:

   393

            self.AppFrame.RefreshLibraryPanel()

   394

            self.AppFrame.RefreshEditor()

   395

   396

    # Update a PLCOpenEditor Pou variable location

   397

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   398

        self.Project.updateElementAddress(old_leading, new_leading)

   399

        self.BufferProject()

   400

        if self.AppFrame is not None:

   401

            self.AppFrame.RefreshTitle()

   402

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   403

            self.AppFrame.RefreshFileMenu()

   404

            self.AppFrame.RefreshEditMenu()

   405

            self.AppFrame.RefreshEditor()

   406

   407

    def GetVariableLocationTree(self):

   408

        '''

   409

        This function is meant to be overridden by confnodes.

   410

   411

        It should returns an list of dictionaries

   412

   413

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

   414

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

   415

        '''

   416

        children = []

   417

        for child in self.IECSortedChildren():

   418

            children.append(child.GetVariableLocationTree())

   419

        return children

   420

   421

    def ConfNodePath(self):

   422

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

   423

   424

    def CTNPath(self, CTNName=None):

   425

        return self.ProjectPath

   426

   427

    def ConfNodeXmlFilePath(self, CTNName=None):

   428

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

   429

   430

    def ParentsTypesFactory(self):

   431

        return self.ConfNodeTypesFactory()

   432

   433

    def _setBuildPath(self, buildpath):

   434

        if CheckPathPerm(buildpath):

   435

            self.BuildPath = buildpath

   436

        else:

   437

            self.BuildPath = None

   438

        self.BuildPath = buildpath

   439

        self.DefaultBuildPath = None

   440

        if self._builder is not None:

   441

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

   442

   443

    def _getBuildPath(self):

   444

        # BuildPath is defined by user

   445

        if self.BuildPath is not None:

   446

            return self.BuildPath

   447

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

   448

        if self.DefaultBuildPath is not None:

   449

            return self.DefaultBuildPath

   450

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

   451

        if CheckPathPerm(self.ProjectPath):

   452

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

   453

        # Create a build path in temp folder

   454

        else:

   455

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

   456

   457

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

   458

            os.makedirs(self.DefaultBuildPath)

   459

        return self.DefaultBuildPath

   460

   461

    def _getExtraFilesPath(self):

   462

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

   463

   464

    def _getIECcodepath(self):

   465

        # define name for IEC code file

   466

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

   467

   468

    def _getIECgeneratedcodepath(self):

   469

        # define name for IEC generated code file

   470

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

   471

   472

    def _getIECrawcodepath(self):

   473

        # define name for IEC raw code file

   474

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

   475

   476

    def GetLocations(self):

   477

        locations = []

   478

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

   479

        if os.path.isfile(filepath):

   480

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

   481

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

   482

            # each line of LOCATED_VARIABLES.h declares a located variable

   483

            lines = [line.strip() for line in location_file.readlines()]

   484

            # This regular expression parses the lines genereated by IEC2C