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.ConfNodeMethods = [dic.copy() for dic in self.ConfNodeMethods]

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

   234

        """

   235

        Create a new project in an empty folder

   236

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

   237

        @param PLCParams: properties of the PLCOpen program created

   238

        """

   239

        # Verify that chosen folder is empty

   240

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

   241

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

   242

   243

        # Create PLCOpen program

   244

        self.CreateNewProject(

   245

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

   246

             "productName": _("Unnamed"),

   247

             "productVersion": _("1"),

   248

             "companyName": _("Unknown"),

   249

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

   250

        self.ProjectAddConfiguration("config")

   251

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

   252

   253

        # Change XSD into class members

   254

        self._AddParamsMembers()

   255

        self.Children = {}

   256

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

   257

        self.ProjectPath = ProjectPath

   258

        self._setBuildPath(BuildPath)

   259

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

   260

        self.RefreshConfNodesBlockLists()

   261

        # this will create files base XML files

   262

        self.SaveProject()

   263

        return None

   264

   265

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

   266

        """

   267

        Load a project contained in a folder

   268

        @param ProjectPath: path of the project folder

   269

        """

   270

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

   271

            ProjectPath = os.path.dirname(ProjectPath)

   272

		# Verify that project contains a PLCOpen program

   273

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

   274

        if not os.path.isfile(plc_file):

   275

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

   276

        # Load PLCOpen file

   277

        result = self.OpenXMLFile(plc_file)

   278

        if result:

   279

            return result

   280

        # Change XSD into class members

   281

        self._AddParamsMembers()

   282

        self.Children = {}

   283

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

   284

        self.ProjectPath = ProjectPath

   285

        self._setBuildPath(BuildPath)

   286

        # If dir have already be made, and file exist

   287

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

   288

            #Load the confnode.xml file into parameters members

   289

            result = self.LoadXMLParams()

   290

            if result:

   291

                return result

   292

            #Load and init all the children

   293

            self.LoadChildren()

   294

        self.RefreshConfNodesBlockLists()

   295

   296

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

   297

            self.EnableMethod("_Clean", True)

   298

   299

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

   300

            self.ShowMethod("_showIECcode", True)

   301

   302

        return None

   303

   304

    def RecursiveConfNodeInfos(self, confnode):

   305

        values = []

   306

        for CTNChild in confnode.IECSortedChildren():

   307

            values.append(

   308

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

   309

                                     CTNChild.CTNName()), 

   310

                 "type": ITEM_CONFNODE, 

   311

                 "confnode": CTNChild,

   312

                 "icon": CTNChild.GetIconPath(),

   313

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

   314

        return values

   315

   316

    def GetProjectInfos(self):

   317

        infos = PLCControler.GetProjectInfos(self)

   318

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

   319

        resources = None

   320

        for config_infos in configurations["values"]:

   321

            if resources is None:

   322

                resources = config_infos["values"][0]

   323

            else:

   324

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

   325

        if resources is not None:

   326

            infos["values"].append(resources)

   327

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

   328

        return infos

   329

   330

    def CloseProject(self):

   331

        self.ClearChildren()

   332

        self.ResetAppFrame(None)

   333

   334

    def SaveProject(self):

   335

        if self.CheckProjectPathPerm(False):

   336

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

   337

            result = self.CTNRequestSave()

   338

            if result:

   339

                self.logger.write_error(result)

   340

   341

    def SaveProjectAs(self, dosave=True):

   342

        # Ask user to choose a path with write permissions

   343

        if wx.Platform == '__WXMSW__':

   344

            path = os.getenv("USERPROFILE")

   345

        else:

   346

            path = os.getenv("HOME")

   347

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

   348

        answer = dirdialog.ShowModal()

   349

        dirdialog.Destroy()

   350

        if answer == wx.ID_OK:

   351

            newprojectpath = dirdialog.GetPath()

   352

            if os.path.isdir(newprojectpath):

   353

                self.ProjectPath = newprojectpath

   354

                if dosave:

   355

                    self.SaveProject()

   356

                self._setBuildPath(self.BuildPath)

   357

                return True

   358

        return False

   359

   360

    def GetLibrariesTypes(self):

   361

        self.LoadLibraries()

   362

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

   363

   364

    def GetLibrariesSTCode(self):

   365

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

   366

   367

    def GetLibrariesCCode(self, buildpath):

   368

        self.GetIECProgramsAndVariables()

   369

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

   370

        LocatedCCodeAndFlags=[]

   371

        Extras=[]

   372

        for lib in self.Libraries:

   373

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

   374

            LocatedCCodeAndFlags.append(res[:2])

   375

            if len(res)>2:

   376

                Extras.append(res[2:])

   377

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

   378

   379

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   380

    def RefreshConfNodesBlockLists(self):

   381

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

   382

            self.ClearConfNodeTypes()

   383

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   384

        if self.AppFrame is not None:

   385

            self.AppFrame.RefreshLibraryPanel()

   386

            self.AppFrame.RefreshEditor()

   387

   388

    # Update a PLCOpenEditor Pou variable location

   389

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   390

        self.Project.updateElementAddress(old_leading, new_leading)

   391

        self.BufferProject()

   392

        if self.AppFrame is not None:

   393

            self.AppFrame.RefreshTitle()

   394

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   395

            self.AppFrame.RefreshFileMenu()

   396

            self.AppFrame.RefreshEditMenu()

   397

            self.AppFrame.RefreshEditor()

   398

   399

    def GetVariableLocationTree(self):

   400

        '''

   401

        This function is meant to be overridden by confnodes.

   402

   403

        It should returns an list of dictionaries

   404

   405

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

   406

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

   407

        '''

   408

        children = []

   409

        for child in self.IECSortedChildren():

   410

            children.append(child.GetVariableLocationTree())

   411

        return children

   412

   413

    def ConfNodePath(self):

   414

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

   415

   416

    def CTNPath(self, CTNName=None):

   417

        return self.ProjectPath

   418

   419

    def ConfNodeXmlFilePath(self, CTNName=None):

   420

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

   421

   422

    def ParentsTypesFactory(self):

   423

        return self.ConfNodeTypesFactory()

   424

   425

    def _setBuildPath(self, buildpath):

   426

        if CheckPathPerm(buildpath):

   427

            self.BuildPath = buildpath

   428

        else:

   429

            self.BuildPath = None

   430

        self.BuildPath = buildpath

   431

        self.DefaultBuildPath = None

   432

        if self._builder is not None:

   433

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

   434

   435

    def _getBuildPath(self):

   436

        # BuildPath is defined by user

   437

        if self.BuildPath is not None:

   438

            return self.BuildPath

   439

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

   440

        if self.DefaultBuildPath is not None:

   441

            return self.DefaultBuildPath

   442

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

   443

        if CheckPathPerm(self.ProjectPath):

   444

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

   445

        # Create a build path in temp folder

   446

        else:

   447

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

   448

   449

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

   450

            os.makedirs(self.DefaultBuildPath)

   451

        return self.DefaultBuildPath

   452

   453

    def _getExtraFilesPath(self):

   454

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

   455

   456

    def _getIECcodepath(self):

   457

        # define name for IEC code file

   458

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

   459

   460

    def _getIECgeneratedcodepath(self):

   461

        # define name for IEC generated code file

   462

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

   463

   464

    def _getIECrawcodepath(self):

   465

        # define name for IEC raw code file

   466

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

   467

   468

    def GetLocations(self):

   469

        locations = []

   470

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

   471

        if os.path.isfile(filepath):

   472

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

   473

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

   474

            # each line of LOCATED_VARIABLES.h declares a located variable

   475

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

   476

            # This regular expression parses the lines genereated by IEC2C

   477

            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]*)\)")

   478

            for line in lines:

   479

                # If line match RE, 

   480

                result = LOCATED_MODEL.match(line)

   481

                if result:

   482

                    # Get the resulting dict

   483

                    resdict = result.groupdict()

   484

                    # rewrite string for variadic location as a tuple of integers