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

    18

from util.ProcessLogger import ProcessLogger

    19

from PLCControler import PLCControler

    20

from PLCOpenEditor import CWD

    21

from TextViewer import TextViewer

    22

from plcopen.structures import IEC_KEYWORDS

    23

from targets.typemapping import DebugTypesSize

    24

from util.discovery import DiscoveryDialog

    25

from ConfigTreeNode import ConfigTreeNode

    26

from ProjectNodeEditor import ProjectNodeEditor

    27

    28

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

    29

    30

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

    31

    32

DEBUG_RETRIES_WARN = 3

    33

DEBUG_RETRIES_REREGISTER = 4

    34

    35

ITEM_CONFNODE = 25

    36

    37

class ProjectController(ConfigTreeNode, PLCControler):

    38

    """

    39

    This class define Root object of the confnode tree. 

    40

    It is responsible of :

    41

    - Managing project directory

    42

    - Building project

    43

    - Handling PLCOpenEditor controler and view

    44

    - Loading user confnodes and instanciante them as children

    45

    - ...

    46

    47

    """

    48

    49

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

    50

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

    51

    52

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

    53

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

    54

      <xsd:element name="BeremizRoot">

    55

        <xsd:complexType>

    56

          <xsd:sequence>

    57

            <xsd:element name="TargetType">

    58

              <xsd:complexType>

    59

                <xsd:choice minOccurs="0">

    60

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

    61

                </xsd:choice>

    62

              </xsd:complexType>

    63

            </xsd:element>

    64

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

    65

              <xsd:complexType>

    66

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

    67

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

    68

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

    69

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

    70

              </xsd:complexType>

    71

            </xsd:element>

    72

          </xsd:sequence>

    73

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

    74

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

    75

        </xsd:complexType>

    76

      </xsd:element>

    77

    </xsd:schema>

    78

    """

    79

    EditorType = ProjectNodeEditor

    80

    81

    def __init__(self, frame, logger):

    82

        PLCControler.__init__(self)

    83

    84

        self.MandatoryParams = None

    85

        self.SetAppFrame(frame, logger)

    86

        self._builder = None

    87

        self._connector = None

    88

    89

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

    90

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

    91

    92

        # Setup debug information

    93

        self.IECdebug_datas = {}

    94

        self.IECdebug_lock = Lock()

    95

    96

        self.DebugTimer=None

    97

        self.ResetIECProgramsAndVariables()

    98

    99

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

   100

        self.ChangesToSave = False

   101

        # root have no parent

   102

        self.CTNParent = None

   103

        # Keep track of the confnode type name

   104

        self.CTNType = "Beremiz"

   105

        self.Children = {}

   106

        self._View = None

   107

        # After __init__ root confnode is not valid

   108

        self.ProjectPath = None

   109

        self._setBuildPath(None)

   110

        self.DebugThread = None

   111

        self.debug_break = False

   112

        self.previous_plcstate = None

   113

        # copy ConfNodeMethods so that it can be later customized

   114

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

   115

   116

    def LoadLibraries(self):

   117

        self.Libraries = []

   118

        TypeStack=[]

   119

        for libname,clsname in features.libraries:

   120

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

   121

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

   122

                TypeStack.append(Lib.GetTypes())

   123

                self.Libraries.append(Lib)

   124

   125

    def __del__(self):

   126

        if self.DebugTimer:

   127

            self.DebugTimer.cancel()

   128

        self.KillDebugThread()

   129

   130

    def SetAppFrame(self, frame, logger):

   131

        self.AppFrame = frame

   132

        self.logger = logger

   133

        self.StatusTimer = None

   134

   135

        if frame is not None:

   136

            # Timer to pull PLC status

   137

            ID_STATUSTIMER = wx.NewId()

   138

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

   139

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

   140

   141

            self.RefreshConfNodesBlockLists()

   142

   143

    def ResetAppFrame(self, logger):

   144

        if self.AppFrame is not None:

   145

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

   146

            self.StatusTimer = None

   147

            self.AppFrame = None

   148

   149

        self.logger = logger

   150

   151

    def CTNName(self):

   152

        return "Project"

   153

   154

    def CTNTestModified(self):

   155

         return self.ChangesToSave or not self.ProjectIsSaved()

   156

   157

    def CTNFullName(self):

   158

        return ""

   159

   160

    def GetCTRoot(self):

   161

        return self

   162

   163

    def GetIECLibPath(self):

   164

        return self.ieclib_path

   165

   166

    def GetIEC2cPath(self):

   167

        return self.iec2c_path

   168

   169

    def GetCurrentLocation(self):

   170

        return ()

   171

   172

    def GetCurrentName(self):

   173

        return ""

   174

   175

    def _GetCurrentName(self):

   176

        return ""

   177

   178

    def GetProjectPath(self):

   179

        return self.ProjectPath

   180

   181

    def GetProjectName(self):

   182

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

   183

   184

    def GetIconPath(self):

   185

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

   186

   187

    def GetDefaultTargetName(self):

   188

        if wx.Platform == '__WXMSW__':

   189

            return "Win32"

   190

        else:

   191

            return "Linux"

   192

   193

    def GetTarget(self):

   194

        target = self.BeremizRoot.getTargetType()

   195

        if target.getcontent() is None:

   196

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

   197

            target_name = self.GetDefaultTargetName()

   198

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

   199

        return target

   200

   201

    def GetParamsAttributes(self, path = None):

   202

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   203

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

   204

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

   205

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

   206

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

   207

        return params

   208

   209

    def SetParamsAttribute(self, path, value):

   210

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

   211

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

   212

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   213

   214

    # helper func to check project path write permission

   215

    def CheckProjectPathPerm(self, dosave=True):

   216

        if CheckPathPerm(self.ProjectPath):

   217

            return True

   218

        dialog = wx.MessageDialog(self.AppFrame, 

   219

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

   220

                    _('Error'), 

   221

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

   222

        answer = dialog.ShowModal()

   223

        dialog.Destroy()

   224

        if answer == wx.ID_YES:

   225

            if self.SaveProjectAs():

   226

                self.AppFrame.RefreshTitle()

   227

                self.AppFrame.RefreshFileMenu()

   228

                self.AppFrame.RefreshPageTitles()

   229

                return True

   230

        return False

   231

   232

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

   233

        """

   234

        Create a new project in an empty folder

   235

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

   236

        @param PLCParams: properties of the PLCOpen program created

   237

        """

   238

        # Verify that chosen folder is empty

   239

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

   240

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

   241

   242

        # Create PLCOpen program

   243

        self.CreateNewProject(

   244

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

   245

             "productName": _("Unnamed"),

   246

             "productVersion": _("1"),

   247

             "companyName": _("Unknown"),

   248

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

   249

        self.ProjectAddConfiguration("config")

   250

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

   251

   252

        # Change XSD into class members

   253

        self._AddParamsMembers()

   254

        self.Children = {}

   255

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

   256

        self.ProjectPath = ProjectPath

   257

        self._setBuildPath(BuildPath)

   258

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

   259

        self.RefreshConfNodesBlockLists()

   260

        # this will create files base XML files

   261

        self.SaveProject()

   262

        return None

   263

   264

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

   265

        """

   266

        Load a project contained in a folder

   267

        @param ProjectPath: path of the project folder

   268

        """

   269

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

   270

            ProjectPath = os.path.dirname(ProjectPath)

   271

		# Verify that project contains a PLCOpen program

   272

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

   273

        if not os.path.isfile(plc_file):

   274

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

   275

        # Load PLCOpen file

   276

        result = self.OpenXMLFile(plc_file)

   277

        if result:

   278

            return result

   279

        # Change XSD into class members

   280

        self._AddParamsMembers()

   281

        self.Children = {}

   282

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

   283

        self.ProjectPath = ProjectPath

   284

        self._setBuildPath(BuildPath)

   285

        # If dir have already be made, and file exist

   286

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

   287

            #Load the confnode.xml file into parameters members

   288

            result = self.LoadXMLParams()

   289

            if result:

   290

                return result

   291

            #Load and init all the children

   292

            self.LoadChildren()

   293

        self.RefreshConfNodesBlockLists()

   294

   295

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

   296

            self.EnableMethod("_Clean", True)

   297

   298

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

   299

            self.ShowMethod("_showIECcode", True)

   300

   301

        return None

   302

   303

    def RecursiveConfNodeInfos(self, confnode):

   304

        values = []

   305

        for CTNChild in confnode.IECSortedChildren():

   306

            values.append(

   307

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

   308

                                     CTNChild.CTNName()), 

   309

                 "type": ITEM_CONFNODE, 

   310

                 "confnode": CTNChild,

   311

                 "icon": CTNChild.GetIconPath(),

   312

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

   313

        return values

   314

   315

    def GetProjectInfos(self):

   316

        infos = PLCControler.GetProjectInfos(self)

   317

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

   318

        resources = None

   319

        for config_infos in configurations["values"]:

   320

            if resources is None:

   321

                resources = config_infos["values"][0]

   322

            else:

   323

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

   324

        if resources is not None:

   325

            infos["values"].append(resources)

   326

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

   327

        return infos

   328

   329

    def CloseProject(self):

   330

        self.ClearChildren()

   331

        self.ResetAppFrame(None)

   332

   333

    def SaveProject(self):

   334

        if self.CheckProjectPathPerm(False):

   335

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

   336

            result = self.CTNRequestSave()

   337

            if result:

   338

                self.logger.write_error(result)

   339

   340

    def SaveProjectAs(self, dosave=True):

   341

        # Ask user to choose a path with write permissions

   342

        if wx.Platform == '__WXMSW__':

   343

            path = os.getenv("USERPROFILE")

   344

        else:

   345

            path = os.getenv("HOME")

   346

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

   347

        answer = dirdialog.ShowModal()

   348

        dirdialog.Destroy()

   349

        if answer == wx.ID_OK:

   350

            newprojectpath = dirdialog.GetPath()

   351

            if os.path.isdir(newprojectpath):

   352

                self.ProjectPath = newprojectpath

   353

                if dosave:

   354

                    self.SaveProject()

   355

                self._setBuildPath(self.BuildPath)

   356

                return True

   357

        return False

   358

   359

    def GetLibrariesTypes(self):

   360

        self.LoadLibraries()

   361

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

   362

   363

    def GetLibrariesSTCode(self):

   364

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

   365

   366

    def GetLibrariesCCode(self, buildpath):

   367

        self.GetIECProgramsAndVariables()

   368

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

   369

        LocatedCCodeAndFlags=[]

   370

        Extras=[]

   371

        for lib in self.Libraries:

   372

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

   373

            LocatedCCodeAndFlags.append(res[:2])

   374

            if len(res)>2:

   375

                Extras.append(res[2:])

   376

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

   377

   378

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   379

    def RefreshConfNodesBlockLists(self):

   380

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

   381

            self.ClearConfNodeTypes()

   382

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   383

        if self.AppFrame is not None:

   384

            self.AppFrame.RefreshLibraryPanel()

   385

            self.AppFrame.RefreshEditor()

   386

   387

    # Update a PLCOpenEditor Pou variable location

   388

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   389

        self.Project.updateElementAddress(old_leading, new_leading)

   390

        self.BufferProject()

   391

        if self.AppFrame is not None:

   392

            self.AppFrame.RefreshTitle()

   393

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   394

            self.AppFrame.RefreshFileMenu()

   395

            self.AppFrame.RefreshEditMenu()

   396

            self.AppFrame.RefreshEditor()

   397

   398

    def GetVariableLocationTree(self):

   399

        '''

   400

        This function is meant to be overridden by confnodes.

   401

   402

        It should returns an list of dictionaries

   403

   404

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

   405

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

   406

        '''

   407

        children = []

   408

        for child in self.IECSortedChildren():

   409

            children.append(child.GetVariableLocationTree())

   410

        return children

   411

   412

    def ConfNodePath(self):

   413

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

   414

   415

    def CTNPath(self, CTNName=None):

   416

        return self.ProjectPath

   417

   418

    def ConfNodeXmlFilePath(self, CTNName=None):

   419

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

   420

   421

    def ParentsTypesFactory(self):

   422

        return self.ConfNodeTypesFactory()

   423

   424

    def _setBuildPath(self, buildpath):

   425

        if CheckPathPerm(buildpath):

   426

            self.BuildPath = buildpath

   427

        else:

   428

            self.BuildPath = None

   429

        self.BuildPath = buildpath

   430

        self.DefaultBuildPath = None

   431

        if self._builder is not None:

   432

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

   433

   434

    def _getBuildPath(self):

   435

        # BuildPath is defined by user

   436

        if self.BuildPath is not None:

   437

            return self.BuildPath

   438

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

   439

        if self.DefaultBuildPath is not None:

   440

            return self.DefaultBuildPath

   441

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

   442

        if CheckPathPerm(self.ProjectPath):

   443

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

   444

        # Create a build path in temp folder

   445

        else:

   446

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

   447

   448

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

   449

            os.makedirs(self.DefaultBuildPath)

   450

        return self.DefaultBuildPath

   451

   452

    def _getExtraFilesPath(self):

   453

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

   454

   455

    def _getIECcodepath(self):

   456

        # define name for IEC code file

   457

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

   458

   459

    def _getIECgeneratedcodepath(self):

   460

        # define name for IEC generated code file

   461

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

   462

   463

    def _getIECrawcodepath(self):

   464

        # define name for IEC raw code file

   465

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

   466

   467

    def GetLocations(self):

   468

        locations = []

   469

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

   470

        if os.path.isfile(filepath):

   471

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

   472

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

   473

            # each line of LOCATED_VARIABLES.h declares a located variable

   474

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

   475

            # This regular expression parses the lines genereated by IEC2C

   476

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

   477

            for line in lines:

   478

                # If line match RE, 

   479

                result = LOCATED_MODEL.match(line)

   480

                if result:

   481

                    # Get the resulting dict

   482

                    resdict = result.groupdict()

   483

                    # rewrite string for variadic location as a tuple of integers

   484

                    resdict['LOC'] = tuple(map(int,resdict['LOC'].split(',')))