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 math import ceil

    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

    17

    18

import targets

    19

import connectors

    20

from util.misc import CheckPathPerm, GetClassImporter

    21

from util.MiniTextControler import MiniTextControler

    22

from util.ProcessLogger import ProcessLogger

    23

from util.BitmapLibrary import GetBitmap

    24

from editors.FileManagementPanel import FileManagementPanel

    25

from editors.ProjectNodeEditor import ProjectNodeEditor

    26

from editors.IECCodeViewer import IECCodeViewer

    27

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    28

from dialogs import DiscoveryDialog

    29

from PLCControler import PLCControler

    30

from plcopen.structures import IEC_KEYWORDS

    31

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    33

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    34

    35

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

    36

    37

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

    38

    39

DEBUG_RETRIES_WARN = 3

    40

DEBUG_RETRIES_REREGISTER = 4

    41

    42

ITEM_CONFNODE = 25

    43

    44

def ExtractChildrenTypesFromCatalog(catalog):

    45

    children_types = []

    46

    for n,d,h,c in catalog:

    47

        if isinstance(c, ListType):

    48

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    49

        else:

    50

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

    51

    return children_types

    52

    53

def ExtractMenuItemsFromCatalog(catalog):

    54

    menu_items = []

    55

    for n,d,h,c in catalog:

    56

        if isinstance(c, ListType):

    57

            children = ExtractMenuItemsFromCatalog(c)

    58

        else:

    59

            children = []

    60

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

    61

    return menu_items

    62

    63

def GetAddMenuItems():

    64

    return ExtractMenuItemsFromCatalog(features.catalog)

    65

    66

class ProjectController(ConfigTreeNode, PLCControler):

    67

    """

    68

    This class define Root object of the confnode tree.

    69

    It is responsible of :

    70

    - Managing project directory

    71

    - Building project

    72

    - Handling PLCOpenEditor controler and view

    73

    - Loading user confnodes and instanciante them as children

    74

    - ...

    75

    76

    """

    77

    78

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

    79

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

    80

    81

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

    82

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

    83

      <xsd:element name="BeremizRoot">

    84

        <xsd:complexType>

    85

          <xsd:sequence>

    86

            <xsd:element name="TargetType">

    87

              <xsd:complexType>

    88

                <xsd:choice minOccurs="0">

    89

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

    90

                </xsd:choice>

    91

              </xsd:complexType>

    92

            </xsd:element>"""+(("""

    93

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

    94

              <xsd:complexType>

    95

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

    96

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

    97

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

    98

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

    99

              </xsd:complexType>

   100

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

   101

          </xsd:sequence>

   102

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

   103

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

   104

        </xsd:complexType>

   105

      </xsd:element>

   106

    </xsd:schema>

   107

    """

   108

    EditorType = ProjectNodeEditor

   109

   110

    def __init__(self, frame, logger):

   111

        PLCControler.__init__(self)

   112

   113

        self.MandatoryParams = None

   114

        self._builder = None

   115

        self._connector = None

   116

        self.DispatchDebugValuesTimer = None

   117

        self.DebugValuesBuffers = []

   118

        self.DebugTicks = []

   119

        self.SetAppFrame(frame, logger)

   120

   121

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

   122

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

   123

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

   124

   125

        # Setup debug information

   126

        self.IECdebug_datas = {}

   127

        self.IECdebug_lock = Lock()

   128

   129

        self.DebugTimer=None

   130

        self.ResetIECProgramsAndVariables()

   131

   132

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

   133

        self.ChangesToSave = False

   134

        # root have no parent

   135

        self.CTNParent = None

   136

        # Keep track of the confnode type name

   137

        self.CTNType = "Beremiz"

   138

        self.Children = {}

   139

        self._View = None

   140

        # After __init__ root confnode is not valid

   141

        self.ProjectPath = None

   142

        self._setBuildPath(None)

   143

        self.DebugThread = None

   144

        self.debug_break = False

   145

        self.previous_plcstate = None

   146

        # copy ConfNodeMethods so that it can be later customized

   147

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

   148

   149

    def __del__(self):

   150

        if self.DebugTimer:

   151

            self.DebugTimer.cancel()

   152

        self.KillDebugThread()

   153

   154

    def LoadLibraries(self):

   155

        self.Libraries = []

   156

        TypeStack=[]

   157

        for libname,clsname in features.libraries:

   158

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

   159

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

   160

                TypeStack.append(Lib.GetTypes())

   161

                self.Libraries.append(Lib)

   162

   163

    def SetAppFrame(self, frame, logger):

   164

        self.AppFrame = frame

   165

        self.logger = logger

   166

        self.StatusTimer = None

   167

        if self.DispatchDebugValuesTimer is not None:

   168

            self.DispatchDebugValuesTimer.Stop()

   169

        self.DispatchDebugValuesTimer = None

   170

   171

        if frame is not None:

   172

   173

            # Timer to pull PLC status

   174

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

   175

            self.AppFrame.Bind(wx.EVT_TIMER,

   176

                self.PullPLCStatusProc, self.StatusTimer)

   177

   178

            if self._connector is not None:

   179

                frame.LogViewer.SetLogSource(self._connector)

   180

                self.StatusTimer.Start(milliseconds=500, oneShot=False)

   181

   182

            # Timer to dispatch debug values to consumers

   183

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

   184

            self.AppFrame.Bind(wx.EVT_TIMER,

   185

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   186

   187

            self.RefreshConfNodesBlockLists()

   188

   189

    def ResetAppFrame(self, logger):

   190

        if self.AppFrame is not None:

   191

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

   192

            self.StatusTimer = None

   193

            self.AppFrame = None

   194

   195

        self.logger = logger

   196

   197

    def CTNName(self):

   198

        return "Project"

   199

   200

    def CTNTestModified(self):

   201

         return self.ChangesToSave or not self.ProjectIsSaved()

   202

   203

    def CTNFullName(self):

   204

        return ""

   205

   206

    def GetCTRoot(self):

   207

        return self

   208

   209

    def GetIECLibPath(self):

   210

        return self.ieclib_c_path

   211

   212

    def GetIEC2cPath(self):

   213

        return self.iec2c_path

   214

   215

    def GetCurrentLocation(self):

   216

        return ()

   217

   218

    def GetCurrentName(self):

   219

        return ""

   220

   221

    def _GetCurrentName(self):

   222

        return ""

   223

   224

    def GetProjectPath(self):

   225

        return self.ProjectPath

   226

   227

    def GetProjectName(self):

   228

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

   229

   230

    def GetIconName(self):

   231

        return "PROJECT"

   232

   233

    def GetDefaultTargetName(self):

   234

        if wx.Platform == '__WXMSW__':

   235

            return "Win32"

   236

        else:

   237

            return "Linux"

   238

   239

    def GetTarget(self):

   240

        target = self.BeremizRoot.getTargetType()

   241

        if target.getcontent() is None:

   242

            temp_root = self.Parser.CreateRoot()

   243

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

   244

            temp_root.setTargetType(target)

   245

            target_name = self.GetDefaultTargetName()

   246

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

   247

        return target

   248

   249

    def GetParamsAttributes(self, path = None):

   250

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   251

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

   252

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

   253

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

   254

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

   255

        return params

   256

   257

    def SetParamsAttribute(self, path, value):

   258

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

   259

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

   260

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

   261

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

   262

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   263

        return res

   264

   265

    # helper func to check project path write permission

   266

    def CheckProjectPathPerm(self, dosave=True):

   267

        if CheckPathPerm(self.ProjectPath):

   268

            return True

   269

        if self.AppFrame is not None:

   270

            dialog = wx.MessageDialog(self.AppFrame,

   271

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

   272

                        _('Error'),

   273

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

   274

            answer = dialog.ShowModal()

   275

            dialog.Destroy()

   276

            if answer == wx.ID_YES:

   277

                if self.SaveProjectAs():

   278

                    self.AppFrame.RefreshTitle()

   279

                    self.AppFrame.RefreshFileMenu()

   280

                    self.AppFrame.RefreshPageTitles()

   281

                    return True

   282

        return False

   283

   284

    def _getProjectFilesPath(self, project_path=None):

   285

        if project_path is not None:

   286

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

   287

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

   288

        if not os.path.exists(projectfiles_path):

   289

            os.mkdir(projectfiles_path)

   290

        return projectfiles_path

   291

   292

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

   293

        self.ProjectAddConfiguration(config_name)

   294

        self.ProjectAddConfigurationResource(config_name, res_name)

   295

   296

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

   297

        """

   298

        Create a new project in an empty folder

   299

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

   300

        @param PLCParams: properties of the PLCOpen program created

   301

        """

   302

        # Verify that chosen folder is empty

   303

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

   304

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

   305

   306

        # Create PLCOpen program

   307

        self.CreateNewProject(

   308

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

   309

             "productName": _("Unnamed"),

   310

             "productVersion": "1",

   311

             "companyName": _("Unknown"),

   312

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

   313

        self.AddProjectDefaultConfiguration()

   314

   315

        # Change XSD into class members

   316

        self._AddParamsMembers()

   317

        self.Children = {}

   318

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

   319

        self.ProjectPath = ProjectPath

   320

        self._setBuildPath(BuildPath)

   321

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

   322

        self.RefreshConfNodesBlockLists()

   323

        # this will create files base XML files

   324

        self.SaveProject()

   325

        return None

   326

   327

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

   328

        """

   329

        Load a project contained in a folder

   330

        @param ProjectPath: path of the project folder

   331

        """

   332

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

   333

            ProjectPath = os.path.dirname(ProjectPath)

   334

        # Verify that project contains a PLCOpen program

   335

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

   336

        if not os.path.isfile(plc_file):

   337

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

   338

        # Load PLCOpen file

   339

        error = self.OpenXMLFile(plc_file)

   340

        if error is not None:

   341

            if self.Project is not None:

   342

                self.logger.write_warning(

   343

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

   344

            else:

   345

                return error

   346

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

   347

            self.AddProjectDefaultConfiguration()

   348

        # Change XSD into class members

   349

        self._AddParamsMembers()

   350

        self.Children = {}

   351

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

   352

        self.ProjectPath = ProjectPath

   353

        self._setBuildPath(BuildPath)

   354

        # If dir have already be made, and file exist

   355

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

   356

            #Load the confnode.xml file into parameters members

   357

            result = self.LoadXMLParams()

   358

            if result:

   359

                return result

   360

            #Load and init all the children

   361

            self.LoadChildren()

   362

        self.RefreshConfNodesBlockLists()

   363

   364

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

   365

            self.EnableMethod("_Clean", True)

   366

   367

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

   368

            self.ShowMethod("_showIECcode", True)

   369

   370

        self.UpdateMethodsFromPLCStatus()

   371

   372

        return None

   373

   374

    def RecursiveConfNodeInfos(self, confnode):

   375

        values = []

   376

        for CTNChild in confnode.IECSortedChildren():

   377

            values.append(

   378

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

   379

                                     CTNChild.CTNName()),

   380

                 "tagname": CTNChild.CTNFullName(),

   381

                 "type": ITEM_CONFNODE,

   382

                 "confnode": CTNChild,

   383

                 "icon": CTNChild.GetIconName(),

   384

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

   385

        return values

   386

   387

    def GetProjectInfos(self):

   388

        infos = PLCControler.GetProjectInfos(self)

   389

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

   390

        resources = None

   391

        for config_infos in configurations["values"]:

   392

            if resources is None:

   393

                resources = config_infos["values"][0]

   394

            else:

   395

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

   396

        if resources is not None:

   397

            infos["values"].append(resources)

   398

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

   399

        return infos

   400

   401

    def CloseProject(self):

   402

        self.ClearChildren()

   403

        self.ResetAppFrame(None)

   404

   405

    def SaveProject(self, from_project_path=None):

   406

        if self.CheckProjectPathPerm(False):

   407

            if from_project_path is not None:

   408

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   409

                if os.path.isdir(old_projectfiles_path):

   410

                    shutil.copytree(old_projectfiles_path,

   411

                                    self._getProjectFilesPath(self.ProjectPath))

   412

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

   413

            result = self.CTNRequestSave(from_project_path)

   414

            if result:

   415

                self.logger.write_error(result)

   416

   417

    def SaveProjectAs(self):

   418

        # Ask user to choose a path with write permissions

   419

        if wx.Platform == '__WXMSW__':

   420

            path = os.getenv("USERPROFILE")

   421

        else:

   422

            path = os.getenv("HOME")

   423

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

   424

        answer = dirdialog.ShowModal()

   425

        dirdialog.Destroy()

   426

        if answer == wx.ID_OK:

   427

            newprojectpath = dirdialog.GetPath()

   428

            if os.path.isdir(newprojectpath):

   429

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   430

                self.SaveProject(old_project_path)

   431

                self._setBuildPath(self.BuildPath)

   432

                return True

   433

        return False

   434

   435

    def GetLibrariesTypes(self):

   436

        self.LoadLibraries()

   437

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

   438

   439

    def GetLibrariesSTCode(self):

   440

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

   441

   442

    def GetLibrariesCCode(self, buildpath):

   443

        if len(self.Libraries)==0:

   444

            return [],[],()

   445

        self.GetIECProgramsAndVariables()

   446

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

   447

        LocatedCCodeAndFlags=[]

   448

        Extras=[]

   449

        for lib in self.Libraries:

   450

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

   451

            LocatedCCodeAndFlags.append(res[:2])

   452

            if len(res)>2:

   453

                Extras.extend(res[2:])

   454

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

   455

   456

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   457

    def RefreshConfNodesBlockLists(self):

   458

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

   459

            self.ClearConfNodeTypes()

   460

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   461

        if self.AppFrame is not None:

   462

            self.AppFrame.RefreshLibraryPanel()

   463

            self.AppFrame.RefreshEditor()

   464

   465

    # Update a PLCOpenEditor Pou variable location

   466

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   467

        self.Project.updateElementAddress(old_leading, new_leading)

   468

        self.BufferProject()

   469

        if self.AppFrame is not None:

   470

            self.AppFrame.RefreshTitle()

   471

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   472

            self.AppFrame.RefreshFileMenu()

   473

            self.AppFrame.RefreshEditMenu()

   474

            wx.CallAfter(self.AppFrame.RefreshEditor)

   475

   476

    def GetVariableLocationTree(self):

   477

        '''

   478

        This function is meant to be overridden by confnodes.

   479

   480

        It should returns an list of dictionaries