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, XSDSchemaErrorMessage

    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:

   224

            temp_root = self.Parser.CreateRoot()

   225

            target = self.Parser.CreateElement("TargetType", "BeremizRoot")

   226

            temp_root.setTargetType(target)

   227

            target_name = self.GetDefaultTargetName()

   228

            target.setcontent(self.Parser.CreateElement(target_name, "TargetType"))

   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

        error = self.OpenXMLFile(plc_file)

   322

        if error is not None:

   323

            if self.Project is not None:

   324

                self.logger.write_warning(

   325

                    XSDSchemaErrorMessage % (("PLC",) + error))

   326

            else:

   327

                return error

   328

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

   329

            self.AddProjectDefaultConfiguration()

   330

        # Change XSD into class members

   331

        self._AddParamsMembers()

   332

        self.Children = {}

   333

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

   334

        self.ProjectPath = ProjectPath

   335

        self._setBuildPath(BuildPath)

   336

        # If dir have already be made, and file exist

   337

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

   338

            #Load the confnode.xml file into parameters members

   339

            result = self.LoadXMLParams()

   340

            if result:

   341

                return result

   342

            #Load and init all the children

   343

            self.LoadChildren()

   344

        self.RefreshConfNodesBlockLists()

   345

   346

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

   347

            self.EnableMethod("_Clean", True)

   348

   349

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

   350

            self.ShowMethod("_showIECcode", True)

   351

   352

        self.UpdateMethodsFromPLCStatus()

   353

   354

        return None

   355

   356

    def RecursiveConfNodeInfos(self, confnode):

   357

        values = []

   358

        for CTNChild in confnode.IECSortedChildren():

   359

            values.append(

   360

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

   361

                                     CTNChild.CTNName()), 

   362

                 "tagname": CTNChild.CTNFullName(),

   363

                 "type": ITEM_CONFNODE, 

   364

                 "confnode": CTNChild,

   365

                 "icon": CTNChild.GetIconName(),

   366

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

   367

        return values

   368

   369

    def GetProjectInfos(self):

   370

        infos = PLCControler.GetProjectInfos(self)

   371

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

   372

        resources = None

   373

        for config_infos in configurations["values"]:

   374

            if resources is None:

   375

                resources = config_infos["values"][0]

   376

            else:

   377

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

   378

        if resources is not None:

   379

            infos["values"].append(resources)

   380

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

   381

        return infos

   382

   383

    def CloseProject(self):

   384

        self.ClearChildren()

   385

        self.ResetAppFrame(None)

   386

   387

    def SaveProject(self, from_project_path=None):

   388

        if self.CheckProjectPathPerm(False):

   389

            if from_project_path is not None:

   390

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   391

                if os.path.isdir(old_projectfiles_path):

   392

                    shutil.copytree(old_projectfiles_path, 

   393

                                    self._getProjectFilesPath(self.ProjectPath))

   394

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

   395

            result = self.CTNRequestSave(from_project_path)

   396

            if result:

   397

                self.logger.write_error(result)

   398

   399

    def SaveProjectAs(self):

   400

        # Ask user to choose a path with write permissions

   401

        if wx.Platform == '__WXMSW__':

   402

            path = os.getenv("USERPROFILE")

   403

        else:

   404

            path = os.getenv("HOME")

   405

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

   406

        answer = dirdialog.ShowModal()

   407

        dirdialog.Destroy()

   408

        if answer == wx.ID_OK:

   409

            newprojectpath = dirdialog.GetPath()

   410

            if os.path.isdir(newprojectpath):

   411

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   412

                self.SaveProject(old_project_path)

   413

                self._setBuildPath(self.BuildPath)

   414

                return True

   415

        return False

   416

   417

    def GetLibrariesTypes(self):

   418

        self.LoadLibraries()

   419

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

   420

   421

    def GetLibrariesSTCode(self):

   422

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

   423

   424

    def GetLibrariesCCode(self, buildpath):

   425

        if len(self.Libraries)==0:

   426

            return [],[],()

   427

        self.GetIECProgramsAndVariables()

   428

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

   429

        LocatedCCodeAndFlags=[]

   430

        Extras=[]

   431

        for lib in self.Libraries:

   432

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

   433

            LocatedCCodeAndFlags.append(res[:2])

   434

            if len(res)>2:

   435

                Extras.extend(res[2:])

   436

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

   437

   438

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   439

    def RefreshConfNodesBlockLists(self):

   440

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

   441

            self.ClearConfNodeTypes()

   442

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   443

        if self.AppFrame is not None:

   444

            self.AppFrame.RefreshLibraryPanel()

   445

            self.AppFrame.RefreshEditor()

   446

   447

    # Update a PLCOpenEditor Pou variable location

   448

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   449

        self.Project.updateElementAddress(old_leading, new_leading)

   450

        self.BufferProject()

   451

        if self.AppFrame is not None:

   452

            self.AppFrame.RefreshTitle()

   453

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   454

            self.AppFrame.RefreshFileMenu()

   455

            self.AppFrame.RefreshEditMenu()

   456

            wx.CallAfter(self.AppFrame.RefreshEditor)

   457

   458

    def GetVariableLocationTree(self):

   459

        '''

   460

        This function is meant to be overridden by confnodes.

   461

   462

        It should returns an list of dictionaries

   463

   464

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

   465

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

   466

        '''

   467

        children = []

   468

        for child in self.IECSortedChildren():

   469

            children.append(child.GetVariableLocationTree())

   470

        return children

   471

   472

    def ConfNodePath(self):

   473

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

   474

   475

    def CTNPath(self, CTNName=None):

   476

        return self.ProjectPath

   477

   478

    def ConfNodeXmlFilePath(self, CTNName=None):

   479

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

   480

   481

    def ParentsTypesFactory(self):

   482

        return self.ConfNodeTypesFactory()

   483