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.misc import CheckPathPerm, GetClassImporter

    18

from util.MiniTextControler import MiniTextControler

    19

from util.ProcessLogger import ProcessLogger

    20

from util.BitmapLibrary import GetBitmap

    21

from editors.FileManagementPanel import FileManagementPanel

    22

from editors.ProjectNodeEditor import ProjectNodeEditor

    23

from editors.IECCodeViewer import IECCodeViewer

    24

from graphics import DebugViewer

    25

from dialogs import DiscoveryDialog

    26

from PLCControler import PLCControler

    27

from plcopen.structures import IEC_KEYWORDS

    28

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    29

from ConfigTreeNode import ConfigTreeNode

    30

    31

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

    32

    33

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

    34

    35

DEBUG_RETRIES_WARN = 3

    36

DEBUG_RETRIES_REREGISTER = 4

    37

    38

ITEM_CONFNODE = 25

    39

    40

class ProjectController(ConfigTreeNode, PLCControler):

    41

    """

    42

    This class define Root object of the confnode tree. 

    43

    It is responsible of :

    44

    - Managing project directory

    45

    - Building project

    46

    - Handling PLCOpenEditor controler and view

    47

    - Loading user confnodes and instanciante them as children

    48

    - ...

    49

    50

    """

    51

    52

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

    53

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

    54

    55

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

    56

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

    57

      <xsd:element name="BeremizRoot">

    58

        <xsd:complexType>

    59

          <xsd:sequence>

    60

            <xsd:element name="TargetType">

    61

              <xsd:complexType>

    62

                <xsd:choice minOccurs="0">

    63

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

    64

                </xsd:choice>

    65

              </xsd:complexType>

    66

            </xsd:element>

    67

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

    68

              <xsd:complexType>

    69

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

    70

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

    71

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

    72

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

    73

              </xsd:complexType>""") if len(features.libraries)>0 else '<xsd:complexType/>') + """

    74

            </xsd:element>

    75

          </xsd:sequence>

    76

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

    77

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

    78

        </xsd:complexType>

    79

      </xsd:element>

    80

    </xsd:schema>

    81

    """

    82

    EditorType = ProjectNodeEditor

    83

    84

    def __init__(self, frame, logger):

    85

        PLCControler.__init__(self)

    86

    87

        self.MandatoryParams = None

    88

        self._builder = None

    89

        self._connector = None

    90

        self.SetAppFrame(frame, logger)

    91

    92

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

    93

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

    94

    95

        # Setup debug information

    96

        self.IECdebug_datas = {}

    97

        self.IECdebug_lock = Lock()

    98

    99

        self.DebugTimer=None

   100

        self.ResetIECProgramsAndVariables()

   101

   102

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

   103

        self.ChangesToSave = False

   104

        # root have no parent

   105

        self.CTNParent = None

   106

        # Keep track of the confnode type name

   107

        self.CTNType = "Beremiz"

   108

        self.Children = {}

   109

        self._View = None

   110

        # After __init__ root confnode is not valid

   111

        self.ProjectPath = None

   112

        self._setBuildPath(None)

   113

        self.DebugThread = None

   114

        self.debug_break = False

   115

        self.previous_plcstate = None

   116

        # copy ConfNodeMethods so that it can be later customized

   117

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

   118

   119

    def LoadLibraries(self):

   120

        self.Libraries = []

   121

        TypeStack=[]

   122

        for libname,clsname in features.libraries:

   123

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

   124

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

   125

                TypeStack.append(Lib.GetTypes())

   126

                self.Libraries.append(Lib)

   127

   128

    def __del__(self):

   129

        if self.DebugTimer:

   130

            self.DebugTimer.cancel()

   131

        self.KillDebugThread()

   132

   133

    def SetAppFrame(self, frame, logger):

   134

        self.AppFrame = frame

   135

        self.logger = logger

   136

        self.StatusTimer = None

   137

   138

        if frame is not None:

   139

            frame.LogViewer.SetLogSource(self._connector)

   140

   141

            # Timer to pull PLC status

   142

            ID_STATUSTIMER = wx.NewId()

   143

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

   144

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

   145

   146

            self.RefreshConfNodesBlockLists()

   147

   148

    def ResetAppFrame(self, logger):

   149

        if self.AppFrame is not None:

   150

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

   151

            self.StatusTimer = None

   152

            self.AppFrame = None

   153

   154

        self.logger = logger

   155

   156

    def CTNName(self):

   157

        return "Project"

   158

   159

    def CTNTestModified(self):

   160

         return self.ChangesToSave or not self.ProjectIsSaved()

   161

   162

    def CTNFullName(self):

   163

        return ""

   164

   165

    def GetCTRoot(self):

   166

        return self

   167

   168

    def GetIECLibPath(self):

   169

        return self.ieclib_path

   170

   171

    def GetIEC2cPath(self):

   172

        return self.iec2c_path

   173

   174

    def GetCurrentLocation(self):

   175

        return ()

   176

   177

    def GetCurrentName(self):

   178

        return ""

   179

   180

    def _GetCurrentName(self):

   181

        return ""

   182

   183

    def GetProjectPath(self):

   184

        return self.ProjectPath

   185

   186

    def GetProjectName(self):

   187

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

   188

   189

    def GetIconName(self):

   190

        return "PROJECT"

   191

   192

    def GetDefaultTargetName(self):

   193

        if wx.Platform == '__WXMSW__':

   194

            return "Win32"

   195

        else:

   196

            return "Linux"

   197

   198

    def GetTarget(self):

   199

        target = self.BeremizRoot.getTargetType()

   200

        if target.getcontent() is None:

   201

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

   202

            target_name = self.GetDefaultTargetName()

   203

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

   204

        return target

   205

   206

    def GetParamsAttributes(self, path = None):

   207

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   208

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

   209

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

   210

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

   211

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

   212

        return params

   213

   214

    def SetParamsAttribute(self, path, value):

   215

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

   216

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

   221

   222

    # helper func to check project path write permission

   223

    def CheckProjectPathPerm(self, dosave=True):

   224

        if CheckPathPerm(self.ProjectPath):

   225

            return True

   239

        return False

   240

   241

    def _getProjectFilesPath(self, project_path=None):

   242

        if project_path is not None:

   243

            return os.path.join(project_path, "project_files")

   244

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

   245

        if not os.path.exists(projectfiles_path):

   246

            os.mkdir(projectfiles_path)

   247

        return projectfiles_path

   248

   249

    def AddProjectDefaultConfiguration(self, config_name="config", res_name="resource1"):

   250

        self.ProjectAddConfiguration(config_name)

   251

        self.ProjectAddConfigurationResource(config_name, res_name)

   252

   253

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

   254

        """

   255

        Create a new project in an empty folder

   256

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

   257

        @param PLCParams: properties of the PLCOpen program created

   258

        """

   259

        # Verify that chosen folder is empty

   260

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

   261

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

   262

   263

        # Create PLCOpen program

   264

        self.CreateNewProject(

   265

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

   266

             "productName": _("Unnamed"),

   267

             "productVersion": "1",

   268

             "companyName": _("Unknown"),

   269

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

   270

        self.AddProjectDefaultConfiguration()

   271

   272

        # Change XSD into class members

   273

        self._AddParamsMembers()

   274

        self.Children = {}

   275

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

   276

        self.ProjectPath = ProjectPath

   277

        self._setBuildPath(BuildPath)

   278

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

   279

        self.RefreshConfNodesBlockLists()

   280

        # this will create files base XML files

   281

        self.SaveProject()

   282

        return None

   283

   284

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

   285

        """

   286

        Load a project contained in a folder

   287

        @param ProjectPath: path of the project folder

   288

        """

   289

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

   290

            ProjectPath = os.path.dirname(ProjectPath)

   291

        # Verify that project contains a PLCOpen program

   292

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

   293

        if not os.path.isfile(plc_file):

   294

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

   295

        # Load PLCOpen file

   296

        result = self.OpenXMLFile(plc_file)

   297

        if result:

   298

            return result

   299

        if len(self.GetProjectConfigNames()) == 0:

   300

            self.AddProjectDefaultConfiguration()

   301

        # Change XSD into class members

   302

        self._AddParamsMembers()

   303

        self.Children = {}

   304

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

   305

        self.ProjectPath = ProjectPath

   306

        self._setBuildPath(BuildPath)

   307

        # If dir have already be made, and file exist

   308

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

   309

            #Load the confnode.xml file into parameters members

   310

            result = self.LoadXMLParams()

   311

            if result:

   312

                return result

   313

            #Load and init all the children

   314

            self.LoadChildren()

   315

        self.RefreshConfNodesBlockLists()

   316

   317

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

   318

            self.EnableMethod("_Clean", True)

   319

   320

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

   321

            self.ShowMethod("_showIECcode", True)

   322

   323

        self.UpdateMethodsFromPLCStatus()

   324

   325

        return None

   326

   327

    def RecursiveConfNodeInfos(self, confnode):

   328

        values = []

   329

        for CTNChild in confnode.IECSortedChildren():

   330

            values.append(

   331

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

   332

                                     CTNChild.CTNName()), 

   333

                 "type": ITEM_CONFNODE, 

   334

                 "confnode": CTNChild,

   335

                 "icon": CTNChild.GetIconName(),

   336

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

   337

        return values

   338

   339

    def GetProjectInfos(self):

   340

        infos = PLCControler.GetProjectInfos(self)

   341

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

   342

        resources = None

   343

        for config_infos in configurations["values"]:

   344

            if resources is None:

   345

                resources = config_infos["values"][0]

   346

            else:

   347

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

   348

        if resources is not None:

   349

            infos["values"].append(resources)

   350

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

   351

        return infos

   352

   353

    def CloseProject(self):

   354

        self.ClearChildren()

   355

        self.ResetAppFrame(None)

   356

   357

    def SaveProject(self, from_project_path=None):

   358

        if self.CheckProjectPathPerm(False):

   359

            if from_project_path is not None:

   360

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   361

                if os.path.isdir(old_projectfiles_path):

   362

                    shutil.copytree(old_projectfiles_path, 

   363

                                    self._getProjectFilesPath(self.ProjectPath))

   364

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

   365

            result = self.CTNRequestSave(from_project_path)

   366

            if result:

   367

                self.logger.write_error(result)

   368

   369

    def SaveProjectAs(self):

   370

        # Ask user to choose a path with write permissions

   371

        if wx.Platform == '__WXMSW__':

   372

            path = os.getenv("USERPROFILE")

   373

        else:

   374

            path = os.getenv("HOME")

   375

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

   376

        answer = dirdialog.ShowModal()

   377

        dirdialog.Destroy()

   378

        if answer == wx.ID_OK:

   379

            newprojectpath = dirdialog.GetPath()

   380

            if os.path.isdir(newprojectpath):

   381

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   382

                self.SaveProject(old_project_path)

   383

                self._setBuildPath(self.BuildPath)

   384

                return True

   385

        return False

   386

   387

    def GetLibrariesTypes(self):

   388

        self.LoadLibraries()

   389

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

   390

   391

    def GetLibrariesSTCode(self):

   392

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

   393

   394

    def GetLibrariesCCode(self, buildpath):

   395

        if len(self.Libraries)==0:

   396

            return [],[],()

   397

        self.GetIECProgramsAndVariables()

   398

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

   399

        LocatedCCodeAndFlags=[]

   400

        Extras=[]

   401

        for lib in self.Libraries:

   402

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

   403

            LocatedCCodeAndFlags.append(res[:2])

   404

            if len(res)>2:

   405

                Extras.extend(res[2:])

   406

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

   407

   408

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   409

    def RefreshConfNodesBlockLists(self):

   410

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

   411

            self.ClearConfNodeTypes()

   412

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   413

        if self.AppFrame is not None:

   414

            self.AppFrame.RefreshLibraryPanel()

   415

            self.AppFrame.RefreshEditor()

   416

   417

    # Update a PLCOpenEditor Pou variable location

   418

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   419

        self.Project.updateElementAddress(old_leading, new_leading)

   420

        self.BufferProject()

   421

        if self.AppFrame is not None:

   422

            self.AppFrame.RefreshTitle()

   423

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   424

            self.AppFrame.RefreshFileMenu()

   425

            self.AppFrame.RefreshEditMenu()

   426

            wx.CallAfter(self.AppFrame.RefreshEditor)

   427

   428

    def GetVariableLocationTree(self):

   429

        '''

   430

        This function is meant to be overridden by confnodes.

   431

   432

        It should returns an list of dictionaries

   433

   434

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

   435

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

   436

        '''

   437

        children = []

   438

        for child in self.IECSortedChildren():

   439

            children.append(child.GetVariableLocationTree())

   440

        return children

   441

   442

    def ConfNodePath(self):

   443

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

   444

   445

    def CTNPath(self, CTNName=None):

   446

        return self.ProjectPath

   447

   448

    def ConfNodeXmlFilePath(self, CTNName=None):

   449

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

   450

   451

    def ParentsTypesFactory(self):

   452

        return self.ConfNodeTypesFactory()

   453

   454

    def _setBuildPath(self, buildpath):

   455

        if CheckPathPerm(buildpath):

   456

            self.BuildPath = buildpath

   457

        else:

   458

            self.BuildPath = None

   459

        self.BuildPath = buildpath

   460

        self.DefaultBuildPath = None

   461

        if self._builder is not None:

   462

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

   463

   464

    def _getBuildPath(self):

   465

        # BuildPath is defined by user

   466

        if self.BuildPath is not None:

   467

            return self.BuildPath

   468

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

   469

        if self.DefaultBuildPath is not None:

   470

            return self.DefaultBuildPath

   471

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

   472

        if CheckPathPerm(self.ProjectPath):

   473

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

   474

        # Create a build path in temp folder

   475

        else:

   476

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

   477

   478

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

   479

            os.makedirs(self.DefaultBuildPath)

   480

        return self.DefaultBuildPath

   481

   482

    def _getExtraFilesPath(self):

   483

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