1

"""

     2

Beremiz Project Controller 

     3

"""

     4

     5

import os,sys,traceback

     6

import time

     7

import features

     8

import shutil

     9

import wx

    10

import re, tempfile

    11

from threading import Timer, Lock, Thread

    12

from time import localtime

    13

from datetime import datetime

    14

from weakref import WeakKeyDictionary

    15

    16

import targets

    17

import connectors

    18

from util import MiniTextControler, opjimg, CheckPathPerm, GetClassImporter

    19

from util.ProcessLogger import ProcessLogger

    20

from PLCControler import PLCControler 

    21

from PLCOpenEditor import ProjectDialog

    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

    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

class ProjectController(ConfigTreeNode, PLCControler):

    36

    """

    37

    This class define Root object of the confnode tree. 

    38

    It is responsible of :

    39

    - Managing project directory

    40

    - Building project

    41

    - Handling PLCOpenEditor controler and view

    42

    - Loading user confnodes and instanciante them as children

    43

    - ...

    44

    45

    """

    46

    47

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

    48

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

    49

    50

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

    51

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

    52

      <xsd:element name="BeremizRoot">

    53

        <xsd:complexType>

    54

          <xsd:sequence>

    55

            <xsd:element name="TargetType">

    56

              <xsd:complexType>

    57

                <xsd:choice minOccurs="0">

    58

                """+targets.targetchoices+"""

    59

                </xsd:choice>

    60

              </xsd:complexType>

    61

            </xsd:element>

    62

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

    63

              <xsd:complexType>

    64

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

    65

                             libname+

    66

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

    67

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

    68

              </xsd:complexType>

    69

            </xsd:element>

    70

          </xsd:sequence>

    71

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

    72

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

    73

        </xsd:complexType>

    74

      </xsd:element>

    75

    </xsd:schema>

    76

    """

    77

    78

    def __init__(self, frame, logger):

    79

        PLCControler.__init__(self)

    80

    81

        self.MandatoryParams = None

    82

        self.SetAppFrame(frame, logger)

    83

        self._builder = None

    84

        self._connector = None

    85

    86

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

    87

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

    88

    89

        # Setup debug information

    90

        self.IECdebug_datas = {}

    91

        self.IECdebug_lock = Lock()

    92

    93

        self.DebugTimer=None

    94

        self.ResetIECProgramsAndVariables()

    95

    96

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

    97

        self.ChangesToSave = False

    98

        # root have no parent

    99

        self.CTNParent = None

   100

        # Keep track of the confnode type name

   101

        self.CTNType = "Beremiz"

   102

        self.Children = {}

   103

        # After __init__ root confnode is not valid

   104

        self.ProjectPath = None

   105

        self._setBuildPath(None)

   106

        self.DebugThread = None

   107

        self.debug_break = False

   108

        self.previous_plcstate = None

   109

        # copy ConfNodeMethods so that it can be later customized

   110

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

   111

   112

    def LoadLibraries(self):

   113

        self.Libraries = []

   114

        TypeStack=[]

   115

        for libname,clsname in features.libraries:

   116

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

   118

                TypeStack.append(Lib.GetTypes())

   119

                self.Libraries.append(Lib)

   120

   121

    def __del__(self):

   122

        if self.DebugTimer:

   123

            self.DebugTimer.cancel()

   124

        self.KillDebugThread()

   125

   126

    def SetAppFrame(self, frame, logger):

   127

        self.AppFrame = frame

   128

        self.logger = logger

   129

        self.StatusTimer = None

   130

   131

        if frame is not None:

   132

            # Timer to pull PLC status

   133

            ID_STATUSTIMER = wx.NewId()

   134

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

   135

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

   136

   137

            self.RefreshConfNodesBlockLists()

   138

   139

    def ResetAppFrame(self, logger):

   140

        if self.AppFrame is not None:

   141

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

   142

            self.StatusTimer = None

   143

            self.AppFrame = None

   144

   145

        self.logger = logger

   146

   147

    def CTNTestModified(self):

   148

         return self.ChangesToSave or not self.ProjectIsSaved()

   149

   150

    def CTNFullName(self):

   151

        return ""

   152

   153

    def GetCTRoot(self):

   154

        return self

   155

   156

    def GetIECLibPath(self):

   157

        return self.ieclib_path

   158

   159

    def GetIEC2cPath(self):

   160

        return self.iec2c_path

   161

   162

    def GetCurrentLocation(self):

   163

        return ()

   164

   165

    def GetCurrentName(self):

   166

        return ""

   167

   168

    def _GetCurrentName(self):

   169

        return ""

   170

   171

    def GetProjectPath(self):

   172

        return self.ProjectPath

   173

   174

    def GetProjectName(self):

   175

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

   176

   177

    def GetDefaultTargetName(self):

   178

        if wx.Platform == '__WXMSW__':

   179

            return "Win32"

   180

        else:

   181

            return "Linux"

   182

   183

    def GetTarget(self):

   184

        target = self.BeremizRoot.getTargetType()

   185

        if target.getcontent() is None:

   186

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

   187

            target_name = self.GetDefaultTargetName()

   188

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

   189

        return target

   190

   191

    def GetParamsAttributes(self, path = None):

   192

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   193

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

   194

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

   195

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

   196

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

   197

        return params

   198

   199

    def SetParamsAttribute(self, path, value):

   200

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

   201

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

   202

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   203

   204

    # helper func to check project path write permission

   205

    def CheckProjectPathPerm(self, dosave=True):

   206

        if CheckPathPerm(self.ProjectPath):

   207

            return True

   208

        dialog = wx.MessageDialog(self.AppFrame, 

   209

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

   210

                    _('Error'), 

   211

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

   212

        answer = dialog.ShowModal()

   213

        dialog.Destroy()

   214

        if answer == wx.ID_YES:

   215

            if self.SaveProjectAs():

   216

                self.AppFrame.RefreshAll()

   217

                self.AppFrame.RefreshTitle()

   218

                self.AppFrame.RefreshFileMenu()

   219

                return True

   220

        return False

   221

   222

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

   223

        """

   224

        Create a new project in an empty folder

   225

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

   226

        @param PLCParams: properties of the PLCOpen program created

   227

        """

   228

        # Verify that chosen folder is empty

   229

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

   230

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

   231

   232

        dialog = ProjectDialog(self.AppFrame)

   233

        if dialog.ShowModal() == wx.ID_OK:

   234

            values = dialog.GetValues()

   235

            values["creationDateTime"] = datetime(*localtime()[:6])

   236

            dialog.Destroy()

   237

        else:

   238

            dialog.Destroy()

   239

            return _("Project not created")

   240

   241

        # Create PLCOpen program

   242

        self.CreateNewProject(values)

   243

        # Change XSD into class members

   244

        self._AddParamsMembers()

   245

        self.Children = {}

   246

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

   247

        self.ProjectPath = ProjectPath

   248

        self._setBuildPath(BuildPath)

   249

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

   250

        self.RefreshConfNodesBlockLists()

   251

        # this will create files base XML files

   252

        self.SaveProject()

   253

        return None

   254

   255

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

   256

        """

   257

        Load a project contained in a folder

   258

        @param ProjectPath: path of the project folder

   259

        """

   260

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

   261

            ProjectPath = os.path.dirname(ProjectPath)

   262

		# Verify that project contains a PLCOpen program

   263

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

   264

        if not os.path.isfile(plc_file):

   265

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

   266

        # Load PLCOpen file

   267

        result = self.OpenXMLFile(plc_file)

   268

        if result:

   269

            return result

   270

        # Change XSD into class members

   271

        self._AddParamsMembers()

   272

        self.Children = {}

   273

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

   274

        self.ProjectPath = ProjectPath

   275

        self._setBuildPath(BuildPath)

   276

        # If dir have already be made, and file exist

   277

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

   278

            #Load the confnode.xml file into parameters members

   279

            result = self.LoadXMLParams()

   280

            if result:

   281

                return result

   282

            #Load and init all the children

   283

            self.LoadChildren()

   284

        self.RefreshConfNodesBlockLists()

   285

   286

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

   287

            self.EnableMethod("_Clean", True)

   288

   289

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

   290

            self.ShowMethod("_showIECcode", True)

   291

   292

        return None

   293

   294

    def CloseProject(self):

   295

        self.ClearChildren()

   296

        self.ResetAppFrame(None)

   297

   298

    def SaveProject(self):

   299

        if self.CheckProjectPathPerm(False):

   300

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

   301

            result = self.CTNRequestSave()

   302

            if result:

   303

                self.logger.write_error(result)

   304

   305

    def SaveProjectAs(self, dosave=True):

   306

        # Ask user to choose a path with write permissions

   307

        if wx.Platform == '__WXMSW__':

   308

            path = os.getenv("USERPROFILE")

   309

        else:

   310

            path = os.getenv("HOME")

   311

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

   312

        answer = dirdialog.ShowModal()

   313

        dirdialog.Destroy()

   314

        if answer == wx.ID_OK:

   315

            newprojectpath = dirdialog.GetPath()

   316

            if os.path.isdir(newprojectpath):

   317

                self.ProjectPath = newprojectpath

   318

                if dosave:

   319

                    self.SaveProject()

   320

                self._setBuildPath(self.BuildPath)

   321

                return True

   322

        return False

   323

   324

    def GetLibrariesTypes(self):

   325

        self.LoadLibraries()

   326

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

   327

   328

    def GetLibrariesSTCode(self):

   329

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

   330

   331

    def GetLibrariesCCode(self, buildpath):

   332

        self.GetIECProgramsAndVariables()

   333

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

   334

        LocatedCCodeAndFlags=[]

   335

        Extras=[]

   336

        for lib in self.Libraries:

   337

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

   338

            LocatedCCodeAndFlags.append(res[:2])

   339

            if len(res)>2:

   340

                Extras.append(res[2:])

   341

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

   342

   343

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   344

    def RefreshConfNodesBlockLists(self):

   345

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

   346

            self.ClearConfNodeTypes()

   347

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   348

        if self.AppFrame is not None:

   349

            self.AppFrame.RefreshLibraryPanel()

   350

            self.AppFrame.RefreshEditor()

   351

   352

    # Update a PLCOpenEditor Pou variable location

   353

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   354

        self.Project.updateElementAddress(old_leading, new_leading)

   355

        self.BufferProject()

   356

        if self.AppFrame is not None:

   357

            self.AppFrame.RefreshTitle()

   358

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   359

            self.AppFrame.RefreshFileMenu()

   360

            self.AppFrame.RefreshEditMenu()

   361

            self.AppFrame.RefreshEditor()

   362

   363

    def GetVariableLocationTree(self):

   364

        '''

   365

        This function is meant to be overridden by confnodes.

   366

   367

        It should returns an list of dictionaries

   368

   369

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

   370

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

   371

        '''

   372

        children = []

   373

        for child in self.IECSortedChildren():

   374

            children.append(child.GetVariableLocationTree())

   375

        return children

   376

   377

    def ConfNodePath(self):

   378

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

   379

   380

    def CTNPath(self, CTNName=None):

   381

        return self.ProjectPath

   382

   383

    def ConfNodeXmlFilePath(self, CTNName=None):

   384

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

   385

   386

    def ParentsTypesFactory(self):

   387

        return self.ConfNodeTypesFactory()

   388

   389

    def _setBuildPath(self, buildpath):

   390

        if CheckPathPerm(buildpath):

   391

            self.BuildPath = buildpath

   392

        else:

   393

            self.BuildPath = None

   394

        self.BuildPath = buildpath

   395

        self.DefaultBuildPath = None

   396

        if self._builder is not None:

   397

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

   398

   399

    def _getBuildPath(self):

   400

        # BuildPath is defined by user

   401

        if self.BuildPath is not None:

   402

            return self.BuildPath

   403

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

   404

        if self.DefaultBuildPath is not None:

   405

            return self.DefaultBuildPath

   406

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

   407

        if CheckPathPerm(self.ProjectPath):

   408

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

   409

        # Create a build path in temp folder

   410

        else:

   411

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

   412

   413

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

   414

            os.makedirs(self.DefaultBuildPath)

   415

        return self.DefaultBuildPath

   416

   417

    def _getExtraFilesPath(self):

   418

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

   419

   420

    def _getIECcodepath(self):

   421

        # define name for IEC code file

   422

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

   423

   424

    def _getIECgeneratedcodepath(self):

   425

        # define name for IEC generated code file

   426

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

   427

   428

    def _getIECrawcodepath(self):

   429

        # define name for IEC raw code file

   430

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

   431

   432

    def GetLocations(self):

   433

        locations = []

   434

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

   435

        if os.path.isfile(filepath):

   436

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

   437

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

   438

            # each line of LOCATED_VARIABLES.h declares a located variable

   439

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

   440

            # This regular expression parses the lines genereated by IEC2C

   441

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

   442

            for line in lines:

   443

                # If line match RE, 

   444

                result = LOCATED_MODEL.match(line)

   445

                if result:

   446

                    # Get the resulting dict

   447

                    resdict = result.groupdict()

   448

                    # rewrite string for variadic location as a tuple of integers

   449

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

   450

                    # set located size to 'X' if not given 

   451

                    if not resdict['SIZE']:

   452

                        resdict['SIZE'] = 'X'

   453

                    # finally store into located variable list

   454

                    locations.append(resdict)

   455

        return locations

   456

   457

    def _Generate_SoftPLC(self):

   458

        """

   459

        Generate SoftPLC ST/IL/SFC code out of PLCOpenEditor controller, and compile it with IEC2C

   460

        @param buildpath: path where files should be created

   461

        """

   462

   463

        # Update PLCOpenEditor ConfNode Block types before generate ST code

   464

        self.RefreshConfNodesBlockLists()

   465

   466

        self.logger.write(_("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n"))

   467

        buildpath = self._getBuildPath()

   468

        # ask PLCOpenEditor controller to write ST/IL/SFC code file

   469

        program, errors, warnings = self.GenerateProgram(self._getIECgeneratedcodepath())

   470

        if len(warnings) > 0:

   471

            self.logger.write_warning(_("Warnings in ST/IL/SFC code generator :\n"))

   472

            for warning in warnings:

   473

                self.logger.write_warning("%s\n"%warning)

   474

        if len(errors) > 0:

   475

            # Failed !

   476

            self.logger.write_error(_("Error in ST/IL/SFC code generator :\n%s\n")%errors[0])

   477

            return False

   478

        plc_file = open(self._getIECcodepath(), "w")

   479

        # Add ST Library from confnodes

   480

        plc_file.write(self.GetLibrariesSTCode())

   481

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

   482

            plc_file.write(open(self._getIECrawcodepath(), "r").read())

   483

            plc_file.write("\n")