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

    11

from types import ListType

    12

from threading import Timer, Lock, Thread

    13

from time import localtime

    14

from datetime import datetime

    15

from weakref import WeakKeyDictionary

    16

    17

import targets

    18

import connectors

    19

from util.misc import CheckPathPerm, GetClassImporter

    20

from util.MiniTextControler import MiniTextControler

    21

from util.ProcessLogger import ProcessLogger

    22

from util.BitmapLibrary import GetBitmap

    23

from editors.FileManagementPanel import FileManagementPanel

    24

from editors.ProjectNodeEditor import ProjectNodeEditor

    25

from editors.IECCodeViewer import IECCodeViewer

    26

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    27

from dialogs import DiscoveryDialog

    28

from PLCControler import PLCControler

    29

from plcopen.structures import IEC_KEYWORDS

    30

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    31

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    32

    33

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

    34

    35

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

    36

    37

DEBUG_RETRIES_WARN = 3

    38

DEBUG_RETRIES_REREGISTER = 4

    39

    40

ITEM_CONFNODE = 25

    41

    42

def ExtractChildrenTypesFromCatalog(catalog):

    43

    children_types = []

    44

    for n,d,h,c in catalog:

    45

        if isinstance(c, ListType):

    46

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    47

        else:

    48

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

    49

    return children_types

    50

    51

def ExtractMenuItemsFromCatalog(catalog):

    52

    menu_items = []

    53

    for n,d,h,c in catalog:

    54

        if isinstance(c, ListType):

    55

            children = ExtractMenuItemsFromCatalog(c)

    56

        else:

    57

            children = []

    58

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

    59

    return menu_items

    60

    61

def GetAddMenuItems():

    62

    return ExtractMenuItemsFromCatalog(features.catalog)

    63

    64

class ProjectController(ConfigTreeNode, PLCControler):

    65

    """

    66

    This class define Root object of the confnode tree. 

    67

    It is responsible of :

    68

    - Managing project directory

    69

    - Building project

    70

    - Handling PLCOpenEditor controler and view

    71

    - Loading user confnodes and instanciante them as children

    72

    - ...

    73

    74

    """

    75

    76

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

    77

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

    78

    79

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

    80

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

    81

      <xsd:element name="BeremizRoot">

    82

        <xsd:complexType>

    83

          <xsd:sequence>

    84

            <xsd:element name="TargetType">

    85

              <xsd:complexType>

    86

                <xsd:choice minOccurs="0">

    87

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

    88

                </xsd:choice>

    89

              </xsd:complexType>

    90

            </xsd:element>

    91

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

    92

              <xsd:complexType>

    93

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

    94

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

    95

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

    96

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

    97

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

    98

            </xsd:element>

    99

          </xsd:sequence>

   100

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

   101

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

   102

        </xsd:complexType>

   103

      </xsd:element>

   104

    </xsd:schema>

   105

    """

   106

    EditorType = ProjectNodeEditor

   107

   108

    def __init__(self, frame, logger):

   109

        PLCControler.__init__(self)

   110

   111

        self.MandatoryParams = None

   112

        self._builder = None

   113

        self._connector = None

   114

        self.DispatchDebugValuesTimer = None

   115

        self.DebugValuesBuffers = []

   116

        self.DebugTicks = []

   117

        self.SetAppFrame(frame, logger)

   118

   119

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

   120

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

   121

   122

        # Setup debug information

   123

        self.IECdebug_datas = {}

   124

        self.IECdebug_lock = Lock()

   125

   126

        self.DebugTimer=None

   127

        self.ResetIECProgramsAndVariables()

   128

   129

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

   130

        self.ChangesToSave = False

   131

        # root have no parent

   132

        self.CTNParent = None

   133

        # Keep track of the confnode type name

   134

        self.CTNType = "Beremiz"

   135

        self.Children = {}

   136

        self._View = None

   137

        # After __init__ root confnode is not valid

   138

        self.ProjectPath = None

   139

        self._setBuildPath(None)

   140

        self.DebugThread = None

   141

        self.debug_break = False

   142

        self.previous_plcstate = None

   143

        # copy ConfNodeMethods so that it can be later customized

   144

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

   145

   146

    def __del__(self):

   147

        if self.DebugTimer:

   148

            self.DebugTimer.cancel()

   149

        self.KillDebugThread()

   150

   151

    def LoadLibraries(self):

   152

        self.Libraries = []

   153

        TypeStack=[]

   154

        for libname,clsname in features.libraries:

   155

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

   156

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

   157

                TypeStack.append(Lib.GetTypes())

   158

                self.Libraries.append(Lib)

   159

   160

    def SetAppFrame(self, frame, logger):

   161

        self.AppFrame = frame

   162

        self.logger = logger

   163

        self.StatusTimer = None

   164

        if self.DispatchDebugValuesTimer is not None:

   165

            self.DispatchDebugValuesTimer.Stop()

   166

        self.DispatchDebugValuesTimer = None

   167

   168

        if frame is not None:

   169

            frame.LogViewer.SetLogSource(self._connector)

   170

   171

            # Timer to pull PLC status

   172

            self.StatusTimer = wx.Timer(self.AppFrame, -1)

   173

            self.AppFrame.Bind(wx.EVT_TIMER, 

   174

                self.PullPLCStatusProc, self.StatusTimer)

   175

   176

            # Timer to dispatch debug values to consumers

   177

            self.DispatchDebugValuesTimer = wx.Timer(self.AppFrame, -1)

   178

            self.AppFrame.Bind(wx.EVT_TIMER, 

   179

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   180

   181

            self.RefreshConfNodesBlockLists()

   182

   183

    def ResetAppFrame(self, logger):

   184

        if self.AppFrame is not None:

   185

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

   186

            self.StatusTimer = None

   187

            self.AppFrame = None

   188

   189

        self.logger = logger

   190

   191

    def CTNName(self):

   192

        return "Project"

   193

   194

    def CTNTestModified(self):

   195

         return self.ChangesToSave or not self.ProjectIsSaved()

   196

   197

    def CTNFullName(self):

   198

        return ""

   199

   200

    def GetCTRoot(self):

   201

        return self

   202

   203

    def GetIECLibPath(self):

   204

        return self.ieclib_path

   205

   206

    def GetIEC2cPath(self):

   207

        return self.iec2c_path

   208

   209

    def GetCurrentLocation(self):

   210

        return ()

   211

   212

    def GetCurrentName(self):

   213

        return ""

   214

   215

    def _GetCurrentName(self):

   216

        return ""

   217

   218

    def GetProjectPath(self):

   219

        return self.ProjectPath

   220

   221

    def GetProjectName(self):

   222

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

   223

   224

    def GetIconName(self):

   225

        return "PROJECT"

   226

   227

    def GetDefaultTargetName(self):

   228

        if wx.Platform == '__WXMSW__':

   229

            return "Win32"

   230

        else:

   231

            return "Linux"

   232

   233

    def GetTarget(self):

   234

        target = self.BeremizRoot.getTargetType()

   235

        if target.getcontent() is None:

   236

            temp_root = self.Parser.CreateRoot()

   237

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

   238

            temp_root.setTargetType(target)

   239

            target_name = self.GetDefaultTargetName()

   240

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

   241

        return target

   242

   243

    def GetParamsAttributes(self, path = None):

   244

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   245

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

   246

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

   247

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

   248

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

   249

        return params

   250

   251

    def SetParamsAttribute(self, path, value):

   252

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

   253

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

   254

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

   255

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

   256

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   257

        return res

   258

   259

    # helper func to check project path write permission

   260

    def CheckProjectPathPerm(self, dosave=True):

   261

        if CheckPathPerm(self.ProjectPath):

   262

            return True

   263

        if self.AppFrame is not None:

   264

            dialog = wx.MessageDialog(self.AppFrame, 

   265

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

   266

                        _('Error'), 

   267

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

   268

            answer = dialog.ShowModal()

   269

            dialog.Destroy()

   270

            if answer == wx.ID_YES:

   271

                if self.SaveProjectAs():

   272

                    self.AppFrame.RefreshTitle()

   273

                    self.AppFrame.RefreshFileMenu()

   274

                    self.AppFrame.RefreshPageTitles()

   275

                    return True

   276

        return False

   277

   278

    def _getProjectFilesPath(self, project_path=None):

   279

        if project_path is not None:

   280

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

   281

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

   282

        if not os.path.exists(projectfiles_path):

   283

            os.mkdir(projectfiles_path)

   284

        return projectfiles_path

   285

   286

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

   287

        self.ProjectAddConfiguration(config_name)

   288

        self.ProjectAddConfigurationResource(config_name, res_name)

   289

   290

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

   291

        """

   292

        Create a new project in an empty folder

   293

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

   294

        @param PLCParams: properties of the PLCOpen program created

   295

        """

   296

        # Verify that chosen folder is empty

   297

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

   298

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

   299

   300

        # Create PLCOpen program

   301

        self.CreateNewProject(

   302

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

   303

             "productName": _("Unnamed"),

   304

             "productVersion": "1",

   305

             "companyName": _("Unknown"),

   306

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

   307

        self.AddProjectDefaultConfiguration()

   308

   309

        # Change XSD into class members

   310

        self._AddParamsMembers()

   311

        self.Children = {}

   312

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

   313

        self.ProjectPath = ProjectPath

   314

        self._setBuildPath(BuildPath)

   315

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

   316

        self.RefreshConfNodesBlockLists()

   317

        # this will create files base XML files

   318

        self.SaveProject()

   319

        return None

   320

   321

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

   322

        """

   323

        Load a project contained in a folder

   324

        @param ProjectPath: path of the project folder

   325

        """

   326

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

   327

            ProjectPath = os.path.dirname(ProjectPath)

   328

        # Verify that project contains a PLCOpen program

   329

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

   330

        if not os.path.isfile(plc_file):

   331

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

   332

        # Load PLCOpen file

   333

        error = self.OpenXMLFile(plc_file)

   334

        if error is not None:

   335

            if self.Project is not None:

   336

                self.logger.write_warning(

   337

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

   338

            else:

   339

                return error

   340

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

   341

            self.AddProjectDefaultConfiguration()

   342

        # Change XSD into class members

   343

        self._AddParamsMembers()

   344

        self.Children = {}

   345

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

   346

        self.ProjectPath = ProjectPath

   347

        self._setBuildPath(BuildPath)

   348

        # If dir have already be made, and file exist

   349

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

   350

            #Load the confnode.xml file into parameters members

   351

            result = self.LoadXMLParams()

   352

            if result:

   353

                return result

   354

            #Load and init all the children

   355

            self.LoadChildren()

   356

        self.RefreshConfNodesBlockLists()

   357

   358

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

   359

            self.EnableMethod("_Clean", True)

   360

   361

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

   362

            self.ShowMethod("_showIECcode", True)

   363

   364

        self.UpdateMethodsFromPLCStatus()

   365

   366

        return None

   367

   368

    def RecursiveConfNodeInfos(self, confnode):

   369

        values = []

   370

        for CTNChild in confnode.IECSortedChildren():

   371

            values.append(

   372

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

   373

                                     CTNChild.CTNName()), 

   374

                 "tagname": CTNChild.CTNFullName(),

   375

                 "type": ITEM_CONFNODE, 

   376

                 "confnode": CTNChild,

   377

                 "icon": CTNChild.GetIconName(),

   378

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

   379

        return values

   380

   381

    def GetProjectInfos(self):

   382

        infos = PLCControler.GetProjectInfos(self)

   383

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

   384

        resources = None

   385

        for config_infos in configurations["values"]:

   386

            if resources is None:

   387

                resources = config_infos["values"][0]

   388

            else:

   389

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

   390

        if resources is not None:

   391

            infos["values"].append(resources)

   392

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

   393

        return infos

   394

   395

    def CloseProject(self):

   396

        self.ClearChildren()

   397

        self.ResetAppFrame(None)

   398

   399

    def SaveProject(self, from_project_path=None):

   400

        if self.CheckProjectPathPerm(False):

   401

            if from_project_path is not None:

   402

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   403

                if os.path.isdir(old_projectfiles_path):

   404

                    shutil.copytree(old_projectfiles_path, 

   405

                                    self._getProjectFilesPath(self.ProjectPath))

   406

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

   407

            result = self.CTNRequestSave(from_project_path)

   408

            if result:

   409

                self.logger.write_error(result)

   410

   411

    def SaveProjectAs(self):

   412

        # Ask user to choose a path with write permissions

   413

        if wx.Platform == '__WXMSW__':

   414

            path = os.getenv("USERPROFILE")

   415

        else:

   416

            path = os.getenv("HOME")

   417

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

   418

        answer = dirdialog.ShowModal()

   419

        dirdialog.Destroy()

   420

        if answer == wx.ID_OK:

   421

            newprojectpath = dirdialog.GetPath()

   422

            if os.path.isdir(newprojectpath):

   423

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   424

                self.SaveProject(old_project_path)

   425

                self._setBuildPath(self.BuildPath)

   426

                return True

   427

        return False

   428

   429

    def GetLibrariesTypes(self):

   430

        self.LoadLibraries()

   431

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

   432

   433

    def GetLibrariesSTCode(self):

   434

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

   435

   436

    def GetLibrariesCCode(self, buildpath):

   437

        if len(self.Libraries)==0:

   438

            return [],[],()

   439

        self.GetIECProgramsAndVariables()

   440

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

   441

        LocatedCCodeAndFlags=[]

   442

        Extras=[]

   443

        for lib in self.Libraries:

   444

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

   445

            LocatedCCodeAndFlags.append(res[:2])

   446

            if len(res)>2:

   447

                Extras.extend(res[2:])

   448

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

   449

   450

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   451

    def RefreshConfNodesBlockLists(self):

   452

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

   453

            self.ClearConfNodeTypes()

   454

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   455

        if self.AppFrame is not None:

   456

            self.AppFrame.RefreshLibraryPanel()

   457

            self.AppFrame.RefreshEditor()

   458

   459

    # Update a PLCOpenEditor Pou variable location

   460

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   461

        self.Project.updateElementAddress(old_leading, new_leading)

   462

        self.BufferProject()

   463

        if self.AppFrame is not None:

   464

            self.AppFrame.RefreshTitle()

   465

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   466

            self.AppFrame.RefreshFileMenu()

   467

            self.AppFrame.RefreshEditMenu()

   468

            wx.CallAfter(self.AppFrame.RefreshEditor)

   469

   470

    def GetVariableLocationTree(self):

   471

        '''

   472

        This function is meant to be overridden by confnodes.

   473

   474

        It should returns an list of dictionaries

   475

   476

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

   477

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

   478

        '''

   479

        children = []

   480

        for child in self.IECSortedChildren():

   481

            children.append(child.GetVariableLocationTree())

   482

        return children

   483