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>

    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

        self.GetIECProgramsAndVariables()

   375

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

   376

        LocatedCCodeAndFlags=[]

   377

        Extras=[]

   378

        for lib in self.Libraries:

   379

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

   380

            LocatedCCodeAndFlags.append(res[:2])

   381

            if len(res)>2:

   382

                Extras.append(res[2:])

   384

   385

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   386

    def RefreshConfNodesBlockLists(self):

   387

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

   388

            self.ClearConfNodeTypes()

   389

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   390

        if self.AppFrame is not None:

   391

            self.AppFrame.RefreshLibraryPanel()

   392

            self.AppFrame.RefreshEditor()

   393

   394

    # Update a PLCOpenEditor Pou variable location

   395

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   396

        self.Project.updateElementAddress(old_leading, new_leading)

   397

        self.BufferProject()

   398

        if self.AppFrame is not None:

   399

            self.AppFrame.RefreshTitle()

   400

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   401

            self.AppFrame.RefreshFileMenu()

   402

            self.AppFrame.RefreshEditMenu()

   403

            self.AppFrame.RefreshEditor()

   404

   405

    def GetVariableLocationTree(self):

   406

        '''

   407

        This function is meant to be overridden by confnodes.

   408

   409

        It should returns an list of dictionaries

   410

   411

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

   412

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

   413

        '''

   414

        children = []

   415

        for child in self.IECSortedChildren():

   416

            children.append(child.GetVariableLocationTree())

   417

        return children

   418

   419

    def ConfNodePath(self):

   420

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

   421

   422

    def CTNPath(self, CTNName=None):

   423

        return self.ProjectPath

   424

   425

    def ConfNodeXmlFilePath(self, CTNName=None):

   426

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

   427

   428

    def ParentsTypesFactory(self):

   429

        return self.ConfNodeTypesFactory()

   430

   431

    def _setBuildPath(self, buildpath):

   432

        if CheckPathPerm(buildpath):

   433

            self.BuildPath = buildpath

   434

        else:

   435

            self.BuildPath = None

   436

        self.BuildPath = buildpath

   437

        self.DefaultBuildPath = None

   438

        if self._builder is not None:

   439

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

   440

   441

    def _getBuildPath(self):

   442

        # BuildPath is defined by user

   443

        if self.BuildPath is not None:

   444

            return self.BuildPath

   445

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

   446

        if self.DefaultBuildPath is not None:

   447

            return self.DefaultBuildPath

   448

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

   449

        if CheckPathPerm(self.ProjectPath):

   450

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

   451

        # Create a build path in temp folder

   452

        else:

   453

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

   454

   455

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

   456

            os.makedirs(self.DefaultBuildPath)

   457

        return self.DefaultBuildPath

   458

   459

    def _getExtraFilesPath(self):

   460

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

   461

   462

    def _getIECcodepath(self):

   463

        # define name for IEC code file

   464

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

   465

   466

    def _getIECgeneratedcodepath(self):

   467

        # define name for IEC generated code file

   468

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

   469

   470

    def _getIECrawcodepath(self):

   471

        # define name for IEC raw code file

   472

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

   473

   474

    def GetLocations(self):

   475

        locations = []

   476

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

   477

        if os.path.isfile(filepath):

   478

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

   479

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

   480

            # each line of LOCATED_VARIABLES.h declares a located variable

   481

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

   482

            # This regular expression parses the lines genereated by IEC2C

   483

            LOCATED_MODEL = re.compile("__LOCATED_VAR\((?P<IEC_TYPE>[A-Z]*),(?P<NAME>[_A-Za-z0-9]*),(?P<DIR>[QMI])(?:,(?P<SIZE>[XBWDL]))?,(?P<LOC>[,0-9]*)\)")

   484