1

"""

     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:sequence>

    63

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

    66

        </xsd:complexType>

    67

      </xsd:element>

    68

    </xsd:schema>

    69

    """

    70

    71

    def __init__(self, frame, logger):

    72

        PLCControler.__init__(self)

    73

    74

        self.MandatoryParams = None

    75

        self.SetAppFrame(frame, logger)

    76

        self._builder = None

    77

        self._connector = None

    78

    79

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

    80

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

    81

    82

        # Setup debug information

    83

        self.IECdebug_datas = {}

    84

        self.IECdebug_lock = Lock()

    85

    86

        self.DebugTimer=None

    87

        self.ResetIECProgramsAndVariables()

    88

    89

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

    90

        self.ChangesToSave = False

    91

        # root have no parent

    92

        self.CTNParent = None

    93

        # Keep track of the confnode type name

    94

        self.CTNType = "Beremiz"

    95

        self.Children = {}

    96

        # After __init__ root confnode is not valid

    97

        self.ProjectPath = None

    98

        self._setBuildPath(None)

    99

        self.DebugThread = None

   100

        self.debug_break = False

   101

        self.previous_plcstate = None

   102

        # copy ConfNodeMethods so that it can be later customized

   103

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

   113

   114

    def __del__(self):

   115

        if self.DebugTimer:

   116

            self.DebugTimer.cancel()

   117

        self.KillDebugThread()

   118

   119

    def SetAppFrame(self, frame, logger):

   120

        self.AppFrame = frame

   121

        self.logger = logger

   122

        self.StatusTimer = None

   123

   124

        if frame is not None:

   125

            # Timer to pull PLC status

   126

            ID_STATUSTIMER = wx.NewId()

   127

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

   128

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

   129

   130

            self.RefreshConfNodesBlockLists()

   131

   132

    def ResetAppFrame(self, logger):

   133

        if self.AppFrame is not None:

   134

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

   135

            self.StatusTimer = None

   136

            self.AppFrame = None

   137

   138

        self.logger = logger

   139

   140

    def CTNTestModified(self):

   141

         return self.ChangesToSave or not self.ProjectIsSaved()

   142

   143

    def CTNFullName(self):

   144

        return ""

   145

   146

    def GetCTRoot(self):

   147

        return self

   148

   149

    def GetIECLibPath(self):

   150

        return self.ieclib_path

   151

   152

    def GetIEC2cPath(self):

   153

        return self.iec2c_path

   154

   155

    def GetCurrentLocation(self):

   156

        return ()

   157

   158

    def GetCurrentName(self):

   159

        return ""

   160

   161

    def _GetCurrentName(self):

   162

        return ""

   163

   164

    def GetProjectPath(self):

   165

        return self.ProjectPath

   166

   167

    def GetProjectName(self):

   168

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

   169

   170

    def GetDefaultTargetName(self):

   171

        if wx.Platform == '__WXMSW__':

   172

            return "Win32"

   173

        else:

   174

            return "Linux"

   175

   176

    def GetTarget(self):

   177

        target = self.BeremizRoot.getTargetType()

   178

        if target.getcontent() is None:

   179

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

   180

            target_name = self.GetDefaultTargetName()

   181

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

   182

        return target

   183

   184

    def GetParamsAttributes(self, path = None):

   185

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   186

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

   187

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

   188

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

   189

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

   190

        return params

   191

   192

    def SetParamsAttribute(self, path, value):

   193

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

   194

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

   195

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   196

   197

    # helper func to check project path write permission

   198

    def CheckProjectPathPerm(self, dosave=True):

   199

        if CheckPathPerm(self.ProjectPath):

   200

            return True

   201

        dialog = wx.MessageDialog(self.AppFrame, 

   202

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

   203

                    _('Error'), 

   204

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

   205

        answer = dialog.ShowModal()

   206

        dialog.Destroy()

   207

        if answer == wx.ID_YES:

   208

            if self.SaveProjectAs():

   209

                self.AppFrame.RefreshAll()

   210

                self.AppFrame.RefreshTitle()

   211

                self.AppFrame.RefreshFileMenu()

   212

                return True

   213

        return False

   214

   215

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

   216

        """

   217

        Create a new project in an empty folder

   218

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

   219

        @param PLCParams: properties of the PLCOpen program created

   220

        """

   221

        # Verify that chosen folder is empty

   222

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

   223

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

   224

   225

        dialog = ProjectDialog(self.AppFrame)

   226

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

   227

            values = dialog.GetValues()

   228

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

   229

            dialog.Destroy()

   230

        else:

   231

            dialog.Destroy()

   232

            return _("Project not created")

   233

   234

        # Create PLCOpen program

   235

        self.CreateNewProject(values)

   236

        # Change XSD into class members

   237

        self._AddParamsMembers()

   238

        self.Children = {}

   239

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

   240

        self.ProjectPath = ProjectPath

   241

        self._setBuildPath(BuildPath)

   242

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

   243

        self.RefreshConfNodesBlockLists()

   244

        # this will create files base XML files

   245

        self.SaveProject()

   246

        return None

   247

   248

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

   249

        """

   250

        Load a project contained in a folder

   251

        @param ProjectPath: path of the project folder

   252

        """

   253

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

   254

            ProjectPath = os.path.dirname(ProjectPath)

   255

		# Verify that project contains a PLCOpen program

   256

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

   257

        if not os.path.isfile(plc_file):

   258

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

   259

        # Load PLCOpen file

   260

        result = self.OpenXMLFile(plc_file)

   261

        if result:

   262

            return result

   263

        # Change XSD into class members

   264

        self._AddParamsMembers()

   265

        self.Children = {}

   266

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

   267

        self.ProjectPath = ProjectPath

   268

        self._setBuildPath(BuildPath)

   269

        # If dir have already be made, and file exist

   270

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

   271

            #Load the confnode.xml file into parameters members

   272

            result = self.LoadXMLParams()

   273

            if result:

   274

                return result

   275

            #Load and init all the children

   276

            self.LoadChildren()

   277

        self.RefreshConfNodesBlockLists()

   278

   279

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

   280

            self.EnableMethod("_Clean", True)

   281

   282

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

   283

            self.ShowMethod("_showIECcode", True)

   284

   285

        return None

   286

   287

    def CloseProject(self):

   288

        self.ClearChildren()

   289

        self.ResetAppFrame(None)

   290

   291

    def SaveProject(self):

   292

        if self.CheckProjectPathPerm(False):

   293

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

   294

            result = self.CTNRequestSave()

   295

            if result:

   296

                self.logger.write_error(result)

   297

   298

    def SaveProjectAs(self, dosave=True):

   299

        # Ask user to choose a path with write permissions

   300

        if wx.Platform == '__WXMSW__':

   301

            path = os.getenv("USERPROFILE")

   302

        else:

   303

            path = os.getenv("HOME")

   304

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

   305

        answer = dirdialog.ShowModal()

   306

        dirdialog.Destroy()

   307

        if answer == wx.ID_OK:

   308

            newprojectpath = dirdialog.GetPath()

   309

            if os.path.isdir(newprojectpath):

   310

                self.ProjectPath = newprojectpath

   311

                if dosave:

   312

                    self.SaveProject()

   313

                self._setBuildPath(self.BuildPath)

   314

                return True

   315

        return False

   335

   336

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   337

    def RefreshConfNodesBlockLists(self):

   338

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

   339

            self.ClearConfNodeTypes()

   341

        if self.AppFrame is not None:

   342

            self.AppFrame.RefreshLibraryPanel()

   343

            self.AppFrame.RefreshEditor()

   344

   345

    # Update a PLCOpenEditor Pou variable location

   346

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   347

        self.Project.updateElementAddress(old_leading, new_leading)

   348

        self.BufferProject()

   349

        if self.AppFrame is not None:

   350

            self.AppFrame.RefreshTitle()

   351

            self.AppFrame.RefreshInstancesTree()

   352

            self.AppFrame.RefreshFileMenu()

   353

            self.AppFrame.RefreshEditMenu()

   354

            self.AppFrame.RefreshEditor()

   355

   356

    def GetVariableLocationTree(self):

   357

        '''

   358

        This function is meant to be overridden by confnodes.

   359

   360

        It should returns an list of dictionaries

   361

   362

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

   363

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

   364

        '''

   365

        children = []

   366

        for child in self.IECSortedChildren():

   367

            children.append(child.GetVariableLocationTree())

   368

        return children

   369

   370

    def ConfNodePath(self):

   371

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

   372

   373

    def CTNPath(self, CTNName=None):

   374

        return self.ProjectPath

   375

   376

    def ConfNodeXmlFilePath(self, CTNName=None):

   377

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

   378

   379

    def ParentsTypesFactory(self):

   380

        return self.ConfNodeTypesFactory()

   381

   382

    def _setBuildPath(self, buildpath):

   383

        if CheckPathPerm(buildpath):

   384

            self.BuildPath = buildpath

   385

        else:

   386

            self.BuildPath = None

   387

        self.BuildPath = buildpath

   388

        self.DefaultBuildPath = None

   389

        if self._builder is not None:

   390

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

   391

   392

    def _getBuildPath(self):

   393

        # BuildPath is defined by user

   394

        if self.BuildPath is not None:

   395

            return self.BuildPath

   396

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

   397

        if self.DefaultBuildPath is not None:

   398

            return self.DefaultBuildPath

   399

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

   400

        if CheckPathPerm(self.ProjectPath):

   401

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

   402

        # Create a build path in temp folder

   403

        else:

   404

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

   405

   406

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

   407

            os.makedirs(self.DefaultBuildPath)

   408

        return self.DefaultBuildPath

   409

   410

    def _getExtraFilesPath(self):

   411

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

   412

   413

    def _getIECcodepath(self):

   414

        # define name for IEC code file

   415

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

   416

   417

    def _getIECgeneratedcodepath(self):

   418

        # define name for IEC generated code file

   419

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

   420

   421

    def _getIECrawcodepath(self):

   422

        # define name for IEC raw code file

   423

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

   424

   425

    def GetLocations(self):

   426

        locations = []

   427

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

   428

        if os.path.isfile(filepath):

   429

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

   430

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

   431

            # each line of LOCATED_VARIABLES.h declares a located variable

   432

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

   433

            # This regular expression parses the lines genereated by IEC2C

   434

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

   435

            for line in lines:

   436

                # If line match RE, 

   437

                result = LOCATED_MODEL.match(line)

   438

                if result:

   439

                    # Get the resulting dict

   440

                    resdict = result.groupdict()

   441

                    # rewrite string for variadic location as a tuple of integers

   442

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

   443

                    # set located size to 'X' if not given 

   444

                    if not resdict['SIZE']:

   445

                        resdict['SIZE'] = 'X'

   446

                    # finally store into located variable list

   447

                    locations.append(resdict)

   448

        return locations

   449

   450

    def _Generate_SoftPLC(self):

   451

        """

   452

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

   453

        @param buildpath: path where files should be created

   454

        """

   455

   456

        # Update PLCOpenEditor ConfNode Block types before generate ST code

   457

        self.RefreshConfNodesBlockLists()

   458

   459

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

   460

        buildpath = self._getBuildPath()

   461

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

   462

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

   463

        if len(warnings) > 0:

   464

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

   465

            for warning in warnings:

   466

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

   467

        if len(errors) > 0:

   468

            # Failed !

   469

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

   470

            return False

   471

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

   472

        # Add ST Library from confnodes

   474

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

   475

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

   476

            plc_file.write("\n")

   477

        plc_file.close()

   478

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

   479

        self.ProgramOffset = 0

   480

        for line in plc_file.xreadlines():

   481

            self.ProgramOffset += 1

   482

        plc_file.close()

   483

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

   484

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