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

    18

from util.MiniTextControler import MiniTextControler

    19

from util.ProcessLogger import ProcessLogger

    20

from PLCControler import PLCControler

    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>""") if len(features.libraries)>0 else '<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.StatusMethods = [dic.copy() for dic in self.StatusMethods]

   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

   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 _getProjectFilesPath(self):

   233

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

   234

        if not os.path.exists(projectfiles_path):

   235

            os.mkdir(projectfiles_path)

   236

        return projectfiles_path

   237

   238

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

   239

        """

   240

        Create a new project in an empty folder

   241

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

   242

        @param PLCParams: properties of the PLCOpen program created

   243

        """

   244

        # Verify that chosen folder is empty

   245

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

   246

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

   247

   248

        # Create PLCOpen program

   249

        self.CreateNewProject(

   250

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

   251

             "productName": _("Unnamed"),

   252

             "productVersion": _("1"),

   253

             "companyName": _("Unknown"),

   254

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

   255

        self.ProjectAddConfiguration("config")

   256

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

   257

   258

        # Change XSD into class members

   259

        self._AddParamsMembers()

   260

        self.Children = {}

   261

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

   262

        self.ProjectPath = ProjectPath

   263

        self._setBuildPath(BuildPath)

   264

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

   265

        self.RefreshConfNodesBlockLists()

   266

        # this will create files base XML files

   267

        self.SaveProject()

   268

        return None

   269

   270

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

   271

        """

   272

        Load a project contained in a folder

   273

        @param ProjectPath: path of the project folder

   274

        """

   275

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

   276

            ProjectPath = os.path.dirname(ProjectPath)

   277

		# Verify that project contains a PLCOpen program

   278

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

   279

        if not os.path.isfile(plc_file):

   280

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

   281

        # Load PLCOpen file

   282

        result = self.OpenXMLFile(plc_file)

   283

        if result:

   284

            return result

   285

        # Change XSD into class members

   286

        self._AddParamsMembers()

   287

        self.Children = {}

   288

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

   289

        self.ProjectPath = ProjectPath

   290

        self._setBuildPath(BuildPath)

   291

        # If dir have already be made, and file exist

   292

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

   293

            #Load the confnode.xml file into parameters members

   294

            result = self.LoadXMLParams()

   295

            if result:

   296

                return result

   297

            #Load and init all the children

   298

            self.LoadChildren()

   299

        self.RefreshConfNodesBlockLists()

   300

   301

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

   302

            self.EnableMethod("_Clean", True)

   303

   304

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

   305

            self.ShowMethod("_showIECcode", True)

   306

   307

        return None

   308

   309

    def RecursiveConfNodeInfos(self, confnode):

   310

        values = []

   311

        for CTNChild in confnode.IECSortedChildren():

   312

            values.append(

   313

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

   314

                                     CTNChild.CTNName()), 

   315

                 "type": ITEM_CONFNODE, 

   316

                 "confnode": CTNChild,

   318

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

   319

        return values

   320

   321

    def GetProjectInfos(self):

   322

        infos = PLCControler.GetProjectInfos(self)

   323

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

   324

        resources = None

   325

        for config_infos in configurations["values"]:

   326

            if resources is None:

   327

                resources = config_infos["values"][0]

   328

            else:

   329

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

   330

        if resources is not None:

   331

            infos["values"].append(resources)

   332

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

   333

        return infos

   334

   335

    def CloseProject(self):

   336

        self.ClearChildren()

   337

        self.ResetAppFrame(None)

   338

   339

    def SaveProject(self):

   340

        if self.CheckProjectPathPerm(False):

   341

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

   342

            result = self.CTNRequestSave()

   343

            if result:

   344

                self.logger.write_error(result)

   345

   346

    def SaveProjectAs(self, dosave=True):

   347

        # Ask user to choose a path with write permissions

   348

        if wx.Platform == '__WXMSW__':

   349

            path = os.getenv("USERPROFILE")

   350

        else:

   351

            path = os.getenv("HOME")

   352

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

   353

        answer = dirdialog.ShowModal()

   354

        dirdialog.Destroy()

   355

        if answer == wx.ID_OK:

   356

            newprojectpath = dirdialog.GetPath()

   357

            if os.path.isdir(newprojectpath):

   358

                self.ProjectPath = newprojectpath

   359

                if dosave:

   360

                    self.SaveProject()

   361

                self._setBuildPath(self.BuildPath)

   362

                return True

   363

        return False

   364

   365

    def GetLibrariesTypes(self):

   366

        self.LoadLibraries()

   367

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

   368

   369

    def GetLibrariesSTCode(self):

   370

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

   371

   372

    def GetLibrariesCCode(self, buildpath):

   373

        if len(self.Libraries)==0:

   374

            return [],[],()

   375

        self.GetIECProgramsAndVariables()

   376

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

   377

        LocatedCCodeAndFlags=[]

   378

        Extras=[]

   379

        for lib in self.Libraries:

   380

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

   381

            LocatedCCodeAndFlags.append(res[:2])

   382

            if len(res)>2:

   383

                Extras.append(res[2:])

   384

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

   385

   386

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   387

    def RefreshConfNodesBlockLists(self):

   388

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

   389

            self.ClearConfNodeTypes()

   390

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   391

        if self.AppFrame is not None:

   392

            self.AppFrame.RefreshLibraryPanel()

   393

            self.AppFrame.RefreshEditor()

   394

   395

    # Update a PLCOpenEditor Pou variable location

   396

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   397

        self.Project.updateElementAddress(old_leading, new_leading)

   398

        self.BufferProject()

   399

        if self.AppFrame is not None:

   400

            self.AppFrame.RefreshTitle()

   401

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   402

            self.AppFrame.RefreshFileMenu()

   403

            self.AppFrame.RefreshEditMenu()

   404

            self.AppFrame.RefreshEditor()

   405

   406

    def GetVariableLocationTree(self):

   407

        '''

   408

        This function is meant to be overridden by confnodes.

   409

   410

        It should returns an list of dictionaries

   411

   412

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

   413

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

   414

        '''

   415

        children = []

   416

        for child in self.IECSortedChildren():

   417

            children.append(child.GetVariableLocationTree())

   418

        return children

   419

   420

    def ConfNodePath(self):

   421

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

   422

   423

    def CTNPath(self, CTNName=None):

   424

        return self.ProjectPath

   425

   426

    def ConfNodeXmlFilePath(self, CTNName=None):

   427

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

   428

   429

    def ParentsTypesFactory(self):

   430

        return self.ConfNodeTypesFactory()

   431

   432

    def _setBuildPath(self, buildpath):

   433

        if CheckPathPerm(buildpath):

   434

            self.BuildPath = buildpath

   435

        else:

   436

            self.BuildPath = None

   437

        self.BuildPath = buildpath

   438

        self.DefaultBuildPath = None

   439

        if self._builder is not None:

   440

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

   441

   442

    def _getBuildPath(self):

   443

        # BuildPath is defined by user

   444

        if self.BuildPath is not None:

   445

            return self.BuildPath

   446

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

   447

        if self.DefaultBuildPath is not None:

   448

            return self.DefaultBuildPath

   449

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

   450

        if CheckPathPerm(self.ProjectPath):

   451

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

   452

        # Create a build path in temp folder

   453

        else:

   454

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

   455

   456

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

   457

            os.makedirs(self.DefaultBuildPath)

   458

        return self.DefaultBuildPath

   459

   460

    def _getExtraFilesPath(self):

   461

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

   462

   463

    def _getIECcodepath(self):

   464

        # define name for IEC code file

   465

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

   466

   467

    def _getIECgeneratedcodepath(self):

   468

        # define name for IEC generated code file

   469

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

   470

   471

    def _getIECrawcodepath(self):

   472

        # define name for IEC raw code file

   473

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

   474

   475

    def GetLocations(self):

   476

        locations = []

   477

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

   478

        if os.path.isfile(filepath):

   479

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

   480

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

   481

            # each line of LOCATED_VARIABLES.h declares a located variable

   482

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

   483

            # This regular expression parses the lines genereated by IEC2C