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 types import ListType

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

    19

from util.MiniTextControler import MiniTextControler

    20

from util.ProcessLogger import ProcessLogger

    21

from util.BitmapLibrary import GetBitmap

    22

from editors.FileManagementPanel import FileManagementPanel

    23

from editors.ProjectNodeEditor import ProjectNodeEditor

    24

from editors.IECCodeViewer import IECCodeViewer

    25

from editors.DebugViewer import DebugViewer

    26

from dialogs import DiscoveryDialog

    27

from PLCControler import PLCControler

    28

from plcopen.structures import IEC_KEYWORDS

    29

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    30

from ConfigTreeNode import ConfigTreeNode

    31

    32

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

    33

    34

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

    35

    36

DEBUG_RETRIES_WARN = 3

    37

DEBUG_RETRIES_REREGISTER = 4

    38

    39

ITEM_CONFNODE = 25

    40

    41

def ExtractChildrenTypesFromCatalog(catalog):

    42

    children_types = []

    43

    for n,d,h,c in catalog:

    44

        if isinstance(c, ListType):

    45

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    46

        else:

    47

            children_types.append((n, GetClassImporter(c), d))

    48

    return children_types

    49

    50

def ExtractMenuItemsFromCatalog(catalog):

    51

    menu_items = []

    52

    for n,d,h,c in catalog:

    53

        if isinstance(c, ListType):

    54

            children = ExtractMenuItemsFromCatalog(c)

    55

        else:

    56

            children = []

    57

        menu_items.append((n, d, h, children))

    58

    return menu_items

    59

    60

def GetAddMenuItems():

    61

    return ExtractMenuItemsFromCatalog(features.catalog)

    62

    63

class ProjectController(ConfigTreeNode, PLCControler):

    64

    """

    65

    This class define Root object of the confnode tree. 

    66

    It is responsible of :

    67

    - Managing project directory

    68

    - Building project

    69

    - Handling PLCOpenEditor controler and view

    70

    - Loading user confnodes and instanciante them as children

    71

    - ...

    72

    73

    """

    74

    75

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

    76

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

    77

    78

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

    79

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

    80

      <xsd:element name="BeremizRoot">

    81

        <xsd:complexType>

    82

          <xsd:sequence>

    83

            <xsd:element name="TargetType">

    84

              <xsd:complexType>

    85

                <xsd:choice minOccurs="0">

    86

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

    87

                </xsd:choice>

    88

              </xsd:complexType>

    89

            </xsd:element>

    90

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

    91

              <xsd:complexType>

    92

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

    93

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

    94

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

    95

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

    96

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

    97

            </xsd:element>

    98

          </xsd:sequence>

    99

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

   100

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

   101

        </xsd:complexType>

   102

      </xsd:element>

   103

    </xsd:schema>

   104

    """

   105

    EditorType = ProjectNodeEditor

   106

   107

    def __init__(self, frame, logger):

   108

        PLCControler.__init__(self)

   109

   110

        self.MandatoryParams = None

   111

        self._builder = None

   112

        self._connector = None

   113

        self.SetAppFrame(frame, logger)

   114

   115

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

   116

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

   117

   118

        # Setup debug information

   119

        self.IECdebug_datas = {}

   120

        self.IECdebug_lock = Lock()

   121

   122

        self.DebugTimer=None

   123

        self.ResetIECProgramsAndVariables()

   124

   125

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

   126

        self.ChangesToSave = False

   127

        # root have no parent

   128

        self.CTNParent = None

   129

        # Keep track of the confnode type name

   130

        self.CTNType = "Beremiz"

   131

        self.Children = {}

   132

        self._View = None

   133

        # After __init__ root confnode is not valid

   134

        self.ProjectPath = None

   135

        self._setBuildPath(None)

   136

        self.DebugThread = None

   137

        self.debug_break = False

   138

        self.previous_plcstate = None

   139

        # copy ConfNodeMethods so that it can be later customized

   140

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

   141

   142

    def __del__(self):

   143

        if self.DebugTimer:

   144

            self.DebugTimer.cancel()

   145

        self.KillDebugThread()

   146

   147

    def LoadLibraries(self):

   148

        self.Libraries = []

   149

        TypeStack=[]

   150

        for libname,clsname in features.libraries:

   151

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

   152

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

   153

                TypeStack.append(Lib.GetTypes())

   154

                self.Libraries.append(Lib)

   155

   156

    def SetAppFrame(self, frame, logger):

   157

        self.AppFrame = frame

   158

        self.logger = logger

   159

        self.StatusTimer = None

   160

   161

        if frame is not None:

   162

            frame.LogViewer.SetLogSource(self._connector)

   163

   164

            # Timer to pull PLC status

   165

            ID_STATUSTIMER = wx.NewId()

   166

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

   167

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

   168

   169

            self.RefreshConfNodesBlockLists()

   170

   171

    def ResetAppFrame(self, logger):

   172

        if self.AppFrame is not None:

   173

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

   174

            self.StatusTimer = None

   175

            self.AppFrame = None

   176

   177

        self.logger = logger

   178

   179

    def CTNName(self):

   180

        return "Project"

   181

   182

    def CTNTestModified(self):

   183

         return self.ChangesToSave or not self.ProjectIsSaved()

   184

   185

    def CTNFullName(self):

   186

        return ""

   187

   188

    def GetCTRoot(self):

   189

        return self

   190

   191

    def GetIECLibPath(self):

   192

        return self.ieclib_path

   193

   194

    def GetIEC2cPath(self):

   195

        return self.iec2c_path

   196

   197

    def GetCurrentLocation(self):

   198

        return ()

   199

   200

    def GetCurrentName(self):

   201

        return ""

   202

   203

    def _GetCurrentName(self):

   204

        return ""

   205

   206

    def GetProjectPath(self):

   207

        return self.ProjectPath

   208

   209

    def GetProjectName(self):

   210

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

   211

   212

    def GetIconName(self):

   213

        return "PROJECT"

   214

   215

    def GetDefaultTargetName(self):

   216

        if wx.Platform == '__WXMSW__':

   217

            return "Win32"

   218

        else:

   219

            return "Linux"

   220

   221

    def GetTarget(self):

   222

        target = self.BeremizRoot.getTargetType()

   223

        if target.getcontent() is None:

   227

            target_name = self.GetDefaultTargetName()

   229

        return target

   230

   231

    def GetParamsAttributes(self, path = None):

   232

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   233

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

   234

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

   235

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

   236

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

   237

        return params

   238

   239

    def SetParamsAttribute(self, path, value):

   240

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

   241

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

   242

        res = ConfigTreeNode.SetParamsAttribute(self, path, value)

   243

        if path.startswith("BeremizRoot.Libraries."):

   244

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   245

        return res

   246

   247

    # helper func to check project path write permission

   248

    def CheckProjectPathPerm(self, dosave=True):

   249

        if CheckPathPerm(self.ProjectPath):

   250

            return True

   251

        if self.AppFrame is not None:

   252

            dialog = wx.MessageDialog(self.AppFrame, 

   253

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

   254

                        _('Error'), 

   255

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

   256

            answer = dialog.ShowModal()

   257

            dialog.Destroy()

   258

            if answer == wx.ID_YES:

   259

                if self.SaveProjectAs():

   260

                    self.AppFrame.RefreshTitle()

   261

                    self.AppFrame.RefreshFileMenu()

   262

                    self.AppFrame.RefreshPageTitles()

   263

                    return True

   264

        return False

   265

   266

    def _getProjectFilesPath(self, project_path=None):

   267

        if project_path is not None:

   268

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

   269

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

   270

        if not os.path.exists(projectfiles_path):

   271

            os.mkdir(projectfiles_path)

   272

        return projectfiles_path

   273

   274

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

   275

        self.ProjectAddConfiguration(config_name)

   276

        self.ProjectAddConfigurationResource(config_name, res_name)

   277

   278

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

   279

        """

   280

        Create a new project in an empty folder

   281

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

   282

        @param PLCParams: properties of the PLCOpen program created

   283

        """

   284

        # Verify that chosen folder is empty

   285

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

   286

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

   287

   288

        # Create PLCOpen program

   289

        self.CreateNewProject(

   290

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

   291

             "productName": _("Unnamed"),

   292

             "productVersion": "1",

   293

             "companyName": _("Unknown"),

   294

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

   295

        self.AddProjectDefaultConfiguration()

   296

   297

        # Change XSD into class members

   298

        self._AddParamsMembers()

   299

        self.Children = {}

   300

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

   301

        self.ProjectPath = ProjectPath

   302

        self._setBuildPath(BuildPath)

   303

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

   304

        self.RefreshConfNodesBlockLists()

   305

        # this will create files base XML files

   306

        self.SaveProject()

   307

        return None

   308

   309

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

   310

        """

   311

        Load a project contained in a folder

   312

        @param ProjectPath: path of the project folder

   313

        """

   314

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

   315

            ProjectPath = os.path.dirname(ProjectPath)

   316

        # Verify that project contains a PLCOpen program

   317

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

   318

        if not os.path.isfile(plc_file):

   319

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

   320

        # Load PLCOpen file

   321

        result = self.OpenXMLFile(plc_file)

   322

        if result:

   323

            return result

   324

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

   325

            self.AddProjectDefaultConfiguration()

   326

        # Change XSD into class members

   327

        self._AddParamsMembers()

   328

        self.Children = {}

   329

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

   330

        self.ProjectPath = ProjectPath

   331

        self._setBuildPath(BuildPath)

   332

        # If dir have already be made, and file exist

   333

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

   334

            #Load the confnode.xml file into parameters members

   335

            result = self.LoadXMLParams()

   336

            if result:

   337

                return result

   338

            #Load and init all the children

   339

            self.LoadChildren()

   340

        self.RefreshConfNodesBlockLists()

   341

   342

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

   343

            self.EnableMethod("_Clean", True)

   344

   345

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

   346

            self.ShowMethod("_showIECcode", True)

   347

   348

        self.UpdateMethodsFromPLCStatus()

   349

   350

        return None

   351

   352

    def RecursiveConfNodeInfos(self, confnode):

   353

        values = []

   354

        for CTNChild in confnode.IECSortedChildren():

   355

            values.append(

   356

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

   357

                                     CTNChild.CTNName()), 

   358

                 "tagname": CTNChild.CTNFullName(),

   359

                 "type": ITEM_CONFNODE, 

   360

                 "confnode": CTNChild,

   361

                 "icon": CTNChild.GetIconName(),

   362

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

   363

        return values

   364

   365

    def GetProjectInfos(self):

   366

        infos = PLCControler.GetProjectInfos(self)

   367

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

   368

        resources = None

   369

        for config_infos in configurations["values"]:

   370

            if resources is None:

   371

                resources = config_infos["values"][0]

   372

            else:

   373

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

   374

        if resources is not None:

   375

            infos["values"].append(resources)

   376

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

   377

        return infos

   378

   379

    def CloseProject(self):

   380

        self.ClearChildren()

   381

        self.ResetAppFrame(None)

   382

   383

    def SaveProject(self, from_project_path=None):

   384

        if self.CheckProjectPathPerm(False):

   385

            if from_project_path is not None:

   386

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   387

                if os.path.isdir(old_projectfiles_path):

   388

                    shutil.copytree(old_projectfiles_path, 

   389

                                    self._getProjectFilesPath(self.ProjectPath))

   390

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

   391

            result = self.CTNRequestSave(from_project_path)

   392

            if result:

   393

                self.logger.write_error(result)

   394

   395

    def SaveProjectAs(self):

   396

        # Ask user to choose a path with write permissions

   397

        if wx.Platform == '__WXMSW__':

   398

            path = os.getenv("USERPROFILE")

   399

        else:

   400

            path = os.getenv("HOME")

   401

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

   402

        answer = dirdialog.ShowModal()

   403

        dirdialog.Destroy()

   404

        if answer == wx.ID_OK:

   405

            newprojectpath = dirdialog.GetPath()

   406

            if os.path.isdir(newprojectpath):

   407

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   408

                self.SaveProject(old_project_path)

   409

                self._setBuildPath(self.BuildPath)

   410

                return True

   411

        return False

   412

   413

    def GetLibrariesTypes(self):

   414

        self.LoadLibraries()

   415

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

   416

   417

    def GetLibrariesSTCode(self):

   418

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

   419

   420

    def GetLibrariesCCode(self, buildpath):

   421

        if len(self.Libraries)==0:

   422

            return [],[],()

   423

        self.GetIECProgramsAndVariables()

   424

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

   425

        LocatedCCodeAndFlags=[]

   426

        Extras=[]

   427

        for lib in self.Libraries:

   428

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

   429

            LocatedCCodeAndFlags.append(res[:2])

   430

            if len(res)>2:

   431

                Extras.extend(res[2:])

   432

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

   433

   434

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   435

    def RefreshConfNodesBlockLists(self):

   436

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

   437

            self.ClearConfNodeTypes()

   438

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   439

        if self.AppFrame is not None:

   440

            self.AppFrame.RefreshLibraryPanel()

   441

            self.AppFrame.RefreshEditor()

   442

   443

    # Update a PLCOpenEditor Pou variable location

   444

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   445

        self.Project.updateElementAddress(old_leading, new_leading)

   446

        self.BufferProject()

   447

        if self.AppFrame is not None:

   448

            self.AppFrame.RefreshTitle()

   449

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   450

            self.AppFrame.RefreshFileMenu()

   451

            self.AppFrame.RefreshEditMenu()

   452

            wx.CallAfter(self.AppFrame.RefreshEditor)

   453

   454

    def GetVariableLocationTree(self):

   455

        '''

   456

        This function is meant to be overridden by confnodes.

   457

   458

        It should returns an list of dictionaries

   459

   460

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

   461

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

   462

        '''

   463

        children = []

   464

        for child in self.IECSortedChildren():

   465

            children.append(child.GetVariableLocationTree())

   466

        return children

   467

   468

    def ConfNodePath(self):

   469

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

   470

   471

    def CTNPath(self, CTNName=None):

   472

        return self.ProjectPath

   473

   474

    def ConfNodeXmlFilePath(self, CTNName=None):

   475

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

   476

   477

    def ParentsTypesFactory(self):

   478

        return self.ConfNodeTypesFactory()

   479

   480

    def _setBuildPath(self, buildpath):

   481

        if CheckPathPerm(buildpath):

   482

            self.BuildPath = buildpath

   483