1

"""

     2

Base definitions for beremiz confnodes

     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=""/>

    64

          <xsd:attribute name="Enable_ConfNodes" type="xsd:boolean" use="optional" default="true"/>

    65

        </xsd:complexType>

    66

      </xsd:element>

    67

    </xsd:schema>

    68

    """

    69

    70

    def __init__(self, frame, logger):

    71

        PLCControler.__init__(self)

    72

    73

        self.MandatoryParams = None

    74

        self.SetAppFrame(frame, logger)

    75

        self._builder = None

    76

        self._connector = None

    77

    78

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

    79

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

    80

    81

        # Setup debug information

    82

        self.IECdebug_datas = {}

    83

        self.IECdebug_lock = Lock()

    84

    85

        self.DebugTimer=None

    86

        self.ResetIECProgramsAndVariables()

    87

    88

        #This method are not called here... but in NewProject and OpenProject

    89

        #self._AddParamsMembers()

    90

        #self.Children = {}

    91

    92

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

    93

        self.ChangesToSave = False

    94

        # root have no parent

    95

        self.CTNParent = None

    96

        # Keep track of the confnode type name

    97

        self.CTNType = "Beremiz"

    98

        self.Children = {}

    99

        # After __init__ root confnode is not valid

   100

        self.ProjectPath = None

   101

        self._setBuildPath(None)

   102

        self.DebugThread = None

   103

        self.debug_break = False

   104

        self.previous_plcstate = None

   105

        # copy ConfNodeMethods so that it can be later customized

   106

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

   107

        self.LoadSTLibrary()

   108

   109

    def __del__(self):

   110

        if self.DebugTimer:

   111

            self.DebugTimer.cancel()

   112

        self.KillDebugThread()

   113

   114

    def SetAppFrame(self, frame, logger):

   115

        self.AppFrame = frame

   116

        self.logger = logger

   117

        self.StatusTimer = None

   118

   119

        if frame is not None:

   120

            # Timer to pull PLC status

   121

            ID_STATUSTIMER = wx.NewId()

   122

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

   123

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

   124

   125

            self.RefreshConfNodesBlockLists()

   126

   127

    def ResetAppFrame(self, logger):

   128

        if self.AppFrame is not None:

   129

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

   130

            self.StatusTimer = None

   131

            self.AppFrame = None

   132

   133

        self.logger = logger

   134

   135

    def ConfNodeLibraryFilePath(self):

   136

        return os.path.join(os.path.split(__file__)[0], "pous.xml")

   137

   138

    def CTNTestModified(self):

   139

         return self.ChangesToSave or not self.ProjectIsSaved()

   140

   141

    def CTNFullName(self):

   142

        return ""

   143

   144

    def GetCTRoot(self):

   145

        return self

   146

   147

    def GetIECLibPath(self):

   148

        return self.ieclib_path

   149

   150

    def GetIEC2cPath(self):

   151

        return self.iec2c_path

   152

   153

    def GetCurrentLocation(self):

   154

        return ()

   155

   156

    def GetCurrentName(self):

   157

        return ""

   158

   159

    def _GetCurrentName(self):

   160

        return ""

   161

   162

    def GetProjectPath(self):

   163

        return self.ProjectPath

   164

   165

    def GetProjectName(self):

   166

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

   167

   168

    def GetDefaultTargetName(self):

   169

        if wx.Platform == '__WXMSW__':

   170

            return "Win32"

   171

        else:

   172

            return "Linux"

   173

   174

    def GetTarget(self):

   175

        target = self.BeremizRoot.getTargetType()

   176

        if target.getcontent() is None:

   177

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

   178

            target_name = self.GetDefaultTargetName()

   179

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

   180

        return target

   181

   182

    def GetParamsAttributes(self, path = None):

   183

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   184

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

   185

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

   186

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

   187

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

   188

        return params

   189

   190

    def SetParamsAttribute(self, path, value):

   191

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

   192

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

   193

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   194

   195

    # helper func to check project path write permission

   196

    def CheckProjectPathPerm(self, dosave=True):

   197

        if CheckPathPerm(self.ProjectPath):

   198

            return True

   199

        dialog = wx.MessageDialog(self.AppFrame, 

   200

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

   201

                    _('Error'), 

   202

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

   203

        answer = dialog.ShowModal()

   204

        dialog.Destroy()

   205

        if answer == wx.ID_YES:

   206

            if self.SaveProjectAs():

   207

                self.AppFrame.RefreshAll()

   208

                self.AppFrame.RefreshTitle()

   209

                self.AppFrame.RefreshFileMenu()

   210

                return True

   211

        return False

   212

   213

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

   214

        """

   215

        Create a new project in an empty folder

   216

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

   217

        @param PLCParams: properties of the PLCOpen program created

   218

        """

   219

        # Verify that chosen folder is empty

   220

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

   221

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

   222

   223

        dialog = ProjectDialog(self.AppFrame)

   224

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

   225

            values = dialog.GetValues()

   226

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

   227

            dialog.Destroy()

   228

        else:

   229

            dialog.Destroy()

   230

            return _("Project not created")

   231

   232

        # Create PLCOpen program

   233

        self.CreateNewProject(values)

   234

        # Change XSD into class members

   235

        self._AddParamsMembers()

   236

        self.Children = {}

   237

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

   238

        self.ProjectPath = ProjectPath

   239

        self._setBuildPath(BuildPath)

   240

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

   241

        self.RefreshConfNodesBlockLists()

   242

        # this will create files base XML files

   243

        self.SaveProject()

   244

        return None

   245

   246

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

   247

        """

   248

        Load a project contained in a folder

   249

        @param ProjectPath: path of the project folder

   250

        """

   251

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

   252

            ProjectPath = os.path.dirname(ProjectPath)

   253

		# Verify that project contains a PLCOpen program

   254

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

   255

        if not os.path.isfile(plc_file):

   256

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

   257

        # Load PLCOpen file

   258

        result = self.OpenXMLFile(plc_file)

   259

        if result:

   260

            return result

   261

        # Change XSD into class members

   262

        self._AddParamsMembers()

   263

        self.Children = {}

   264

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

   265

        self.ProjectPath = ProjectPath

   266

        self._setBuildPath(BuildPath)

   267

        # If dir have already be made, and file exist

   268

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

   269

            #Load the confnode.xml file into parameters members

   270

            result = self.LoadXMLParams()

   271

            if result:

   272

                return result

   273

            #Load and init all the children

   274

            self.LoadChildren()

   275

        self.RefreshConfNodesBlockLists()

   276

   277

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

   278

            self.EnableMethod("_Clean", True)

   279

   280

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

   281

            self.ShowMethod("_showIECcode", True)

   282

   283

        return None

   284

   285

    def CloseProject(self):

   286

        self.ClearChildren()

   287

        self.ResetAppFrame(None)

   288

   289

    def SaveProject(self):

   290

        if self.CheckProjectPathPerm(False):

   291

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

   292

            result = self.CTNRequestSave()

   293

            if result:

   294

                self.logger.write_error(result)

   295

   296

    def SaveProjectAs(self, dosave=True):

   297

        # Ask user to choose a path with write permissions

   298

        if wx.Platform == '__WXMSW__':

   299

            path = os.getenv("USERPROFILE")

   300

        else:

   301

            path = os.getenv("HOME")

   302

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

   303

        answer = dirdialog.ShowModal()

   304

        dirdialog.Destroy()

   305

        if answer == wx.ID_OK:

   306

            newprojectpath = dirdialog.GetPath()

   307

            if os.path.isdir(newprojectpath):

   308

                self.ProjectPath = newprojectpath

   309

                if dosave:

   310

                    self.SaveProject()

   311

                self._setBuildPath(self.BuildPath)

   312

                return True

   313

        return False

   314

   315

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   316

    def RefreshConfNodesBlockLists(self):

   317

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

   318

            self.ClearConfNodeTypes()

   319

            self.AddConfNodeTypesList(self.ConfNodesTypesFactory())

   320

        if self.AppFrame is not None:

   321

            self.AppFrame.RefreshLibraryPanel()

   322

            self.AppFrame.RefreshEditor()

   323

   324

    # Update a PLCOpenEditor Pou variable location

   325

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   326

        self.Project.updateElementAddress(old_leading, new_leading)

   327

        self.BufferProject()

   328

        if self.AppFrame is not None:

   329

            self.AppFrame.RefreshTitle()

   330

            self.AppFrame.RefreshInstancesTree()

   331

            self.AppFrame.RefreshFileMenu()

   332

            self.AppFrame.RefreshEditMenu()

   333

            self.AppFrame.RefreshEditor()

   334

   335

    def GetVariableLocationTree(self):

   336

        '''

   337

        This function is meant to be overridden by confnodes.

   338

   339

        It should returns an list of dictionaries

   340

   341

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

   342

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

   343

        '''

   344

        children = []

   345

        for child in self.IECSortedChildren():

   346

            children.append(child.GetVariableLocationTree())

   347

        return children

   348

   349

    def ConfNodePath(self):

   350

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

   351

   352

    def CTNPath(self, CTNName=None):

   353

        return self.ProjectPath

   354

   355

    def ConfNodeXmlFilePath(self, CTNName=None):

   356

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

   357

   358

    def ParentsTypesFactory(self):

   359

        return self.ConfNodeTypesFactory()

   360

   361

    def _setBuildPath(self, buildpath):

   362

        if CheckPathPerm(buildpath):

   363

            self.BuildPath = buildpath

   364

        else:

   365

            self.BuildPath = None

   366

        self.BuildPath = buildpath

   367

        self.DefaultBuildPath = None

   368

        if self._builder is not None:

   369

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

   370

   371

    def _getBuildPath(self):

   372

        # BuildPath is defined by user

   373

        if self.BuildPath is not None:

   374

            return self.BuildPath

   375

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

   376

        if self.DefaultBuildPath is not None:

   377

            return self.DefaultBuildPath

   378

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

   379

        if CheckPathPerm(self.ProjectPath):

   380

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

   381

        # Create a build path in temp folder

   382

        else:

   383

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

   384

   385

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

   386

            os.makedirs(self.DefaultBuildPath)

   387

        return self.DefaultBuildPath

   388

   389

    def _getExtraFilesPath(self):

   390

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

   391

   392

    def _getIECcodepath(self):

   393

        # define name for IEC code file

   394

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

   395

   396

    def _getIECgeneratedcodepath(self):

   397

        # define name for IEC generated code file

   398

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

   399

   400

    def _getIECrawcodepath(self):

   401

        # define name for IEC raw code file

   402

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

   403

   404

    def GetLocations(self):

   405

        locations = []

   406

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

   407

        if os.path.isfile(filepath):

   408

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

   409

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

   410

            # each line of LOCATED_VARIABLES.h declares a located variable

   411

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

   412

            # This regular expression parses the lines genereated by IEC2C

   413

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

   414

            for line in lines:

   415

                # If line match RE, 

   416

                result = LOCATED_MODEL.match(line)

   417

                if result:

   418

                    # Get the resulting dict

   419

                    resdict = result.groupdict()

   420

                    # rewrite string for variadic location as a tuple of integers

   421

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

   422

                    # set located size to 'X' if not given 

   423

                    if not resdict['SIZE']:

   424

                        resdict['SIZE'] = 'X'

   425

                    # finally store into located variable list

   426

                    locations.append(resdict)

   427

        return locations

   428

   429

    def _Generate_SoftPLC(self):

   430

        """

   431

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

   432

        @param buildpath: path where files should be created

   433

        """

   434

   435

        # Update PLCOpenEditor ConfNode Block types before generate ST code

   436

        self.RefreshConfNodesBlockLists()

   437

   438

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

   439

        buildpath = self._getBuildPath()

   440

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

   441

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

   442

        if len(warnings) > 0:

   443

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

   444

            for warning in warnings:

   445

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

   446

        if len(errors) > 0:

   447

            # Failed !

   448

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

   449

            return False

   450

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

   451

        # Add ST Library from confnodes

   452

        plc_file.write(self.ConfNodesSTLibraryFactory())

   453

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

   454

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

   455

            plc_file.write("\n")

   456

        plc_file.close()

   457

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

   458

        self.ProgramOffset = 0

   459

        for line in plc_file.xreadlines():

   460

            self.ProgramOffset += 1

   461

        plc_file.close()

   462

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

   463

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

   464

        plc_file.close()

   465

   466

        self.logger.write(_("Compiling IEC Program into C code...\n"))

   467

   468

        # Now compile IEC code into many C files

   469

        # files are listed to stdout, and errors to stderr. 

   470

        status, result, err_result = ProcessLogger(

   471

               self.logger,

   472

               "\"%s\" -f -I \"%s\" -T \"%s\" \"%s\""%(

   473

                         self.iec2c_path,

   474

                         self.ieclib_path, 

   475

                         buildpath,

   476

                         self._getIECcodepath()),

   477

               no_stdout=True, no_stderr=True).spin()

   478

        if status:

   479

            # Failed !

   480

   481

            # parse iec2c's error message. if it contains a line number,

   482

            # then print those lines from the generated IEC file.

   483

            for err_line in err_result.split('\n'):