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:

   224

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

   225

            target_name = self.GetDefaultTargetName()

   226

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

   227

        return target

   228

   229

    def GetParamsAttributes(self, path = None):

   230

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   231

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

   232

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

   233

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

   234

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

   235

        return params

   236

   237

    def SetParamsAttribute(self, path, value):

   238

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

   239

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

   240

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

   241

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

   242

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   243

        return res

   244

   245

    # helper func to check project path write permission

   246

    def CheckProjectPathPerm(self, dosave=True):

   247

        if CheckPathPerm(self.ProjectPath):

   248

            return True

   249

        if self.AppFrame is not None:

   250

            dialog = wx.MessageDialog(self.AppFrame, 

   251

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

   252

                        _('Error'), 

   253

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

   254

            answer = dialog.ShowModal()

   255

            dialog.Destroy()

   256

            if answer == wx.ID_YES:

   257

                if self.SaveProjectAs():

   258

                    self.AppFrame.RefreshTitle()

   259

                    self.AppFrame.RefreshFileMenu()

   260

                    self.AppFrame.RefreshPageTitles()

   261

                    return True

   262

        return False

   263

   264

    def _getProjectFilesPath(self, project_path=None):

   265

        if project_path is not None:

   266

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

   267

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

   268

        if not os.path.exists(projectfiles_path):

   269

            os.mkdir(projectfiles_path)

   270

        return projectfiles_path

   271

   272

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

   273

        self.ProjectAddConfiguration(config_name)

   274

        self.ProjectAddConfigurationResource(config_name, res_name)

   275

   276

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

   277

        """

   278

        Create a new project in an empty folder

   279

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

   280

        @param PLCParams: properties of the PLCOpen program created

   281

        """

   282

        # Verify that chosen folder is empty

   283

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

   284

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

   285

   286

        # Create PLCOpen program

   287

        self.CreateNewProject(

   288

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

   289

             "productName": _("Unnamed"),

   290

             "productVersion": "1",

   291

             "companyName": _("Unknown"),

   292

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

   293

        self.AddProjectDefaultConfiguration()

   294

   295

        # Change XSD into class members

   296

        self._AddParamsMembers()

   297

        self.Children = {}

   298

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

   299

        self.ProjectPath = ProjectPath

   300

        self._setBuildPath(BuildPath)

   301

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

   302

        self.RefreshConfNodesBlockLists()

   303

        # this will create files base XML files

   304

        self.SaveProject()

   305

        return None

   306

   307

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

   308

        """

   309

        Load a project contained in a folder

   310

        @param ProjectPath: path of the project folder

   311

        """

   312

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

   313

            ProjectPath = os.path.dirname(ProjectPath)

   314

        # Verify that project contains a PLCOpen program

   315

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

   316

        if not os.path.isfile(plc_file):

   317

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

   318

        # Load PLCOpen file

   319

        result = self.OpenXMLFile(plc_file)

   320

        if result:

   321

            return result

   322

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

   323

            self.AddProjectDefaultConfiguration()

   324

        # Change XSD into class members

   325

        self._AddParamsMembers()

   326

        self.Children = {}

   327

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

   328

        self.ProjectPath = ProjectPath

   329

        self._setBuildPath(BuildPath)

   330

        # If dir have already be made, and file exist

   331

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

   332

            #Load the confnode.xml file into parameters members

   333

            result = self.LoadXMLParams()

   334

            if result:

   335

                return result

   336

            #Load and init all the children

   337

            self.LoadChildren()

   338

        self.RefreshConfNodesBlockLists()

   339

   340

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

   341

            self.EnableMethod("_Clean", True)

   342

   343

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

   344

            self.ShowMethod("_showIECcode", True)

   345

   346

        self.UpdateMethodsFromPLCStatus()

   347

   348

        return None

   349

   350

    def RecursiveConfNodeInfos(self, confnode):

   351

        values = []

   352

        for CTNChild in confnode.IECSortedChildren():

   353

            values.append(

   354

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

   355

                                     CTNChild.CTNName()), 

   356

                 "tagname": CTNChild.CTNFullName(),

   357

                 "type": ITEM_CONFNODE, 

   358

                 "confnode": CTNChild,

   359

                 "icon": CTNChild.GetIconName(),

   360

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

   361

        return values

   362

   363

    def GetProjectInfos(self):

   364

        infos = PLCControler.GetProjectInfos(self)

   365

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

   366

        resources = None

   367

        for config_infos in configurations["values"]:

   368

            if resources is None:

   369

                resources = config_infos["values"][0]

   370

            else:

   371

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

   372

        if resources is not None:

   373

            infos["values"].append(resources)

   374

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

   375

        return infos

   376

   377

    def CloseProject(self):

   378

        self.ClearChildren()

   379

        self.ResetAppFrame(None)

   380

   381

    def SaveProject(self, from_project_path=None):

   382

        if self.CheckProjectPathPerm(False):

   383

            if from_project_path is not None:

   384

                old_projectfiles_path = self._getProjectFilesPath(from_project_path)

   385

                if os.path.isdir(old_projectfiles_path):

   386

                    shutil.copytree(old_projectfiles_path, 

   387

                                    self._getProjectFilesPath(self.ProjectPath))

   388

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

   389

            result = self.CTNRequestSave(from_project_path)

   390

            if result:

   391

                self.logger.write_error(result)

   392

   393

    def SaveProjectAs(self):

   394

        # Ask user to choose a path with write permissions

   395

        if wx.Platform == '__WXMSW__':

   396

            path = os.getenv("USERPROFILE")

   397

        else:

   398

            path = os.getenv("HOME")

   399

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

   400

        answer = dirdialog.ShowModal()

   401

        dirdialog.Destroy()

   402

        if answer == wx.ID_OK:

   403

            newprojectpath = dirdialog.GetPath()

   404

            if os.path.isdir(newprojectpath):

   405

                self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath

   406

                self.SaveProject(old_project_path)

   407

                self._setBuildPath(self.BuildPath)

   408

                return True

   409

        return False

   410

   411

    def GetLibrariesTypes(self):

   412

        self.LoadLibraries()

   413

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

   414

   415

    def GetLibrariesSTCode(self):

   416

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

   417

   418

    def GetLibrariesCCode(self, buildpath):

   419

        if len(self.Libraries)==0:

   420

            return [],[],()

   421

        self.GetIECProgramsAndVariables()

   422

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

   423

        LocatedCCodeAndFlags=[]

   424

        Extras=[]

   425

        for lib in self.Libraries:

   426

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

   427

            LocatedCCodeAndFlags.append(res[:2])

   428

            if len(res)>2:

   429

                Extras.extend(res[2:])

   430

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

   431

   432

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   433

    def RefreshConfNodesBlockLists(self):

   434

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

   435

            self.ClearConfNodeTypes()

   436

            self.AddConfNodeTypesList(self.GetLibrariesTypes())

   437

        if self.AppFrame is not None:

   438

            self.AppFrame.RefreshLibraryPanel()

   439

            self.AppFrame.RefreshEditor()

   440

   441

    # Update a PLCOpenEditor Pou variable location

   442

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   443

        self.Project.updateElementAddress(old_leading, new_leading)

   444

        self.BufferProject()

   445

        if self.AppFrame is not None:

   446

            self.AppFrame.RefreshTitle()

   447

            self.AppFrame.RefreshPouInstanceVariablesPanel()

   448

            self.AppFrame.RefreshFileMenu()

   449

            self.AppFrame.RefreshEditMenu()

   450

            wx.CallAfter(self.AppFrame.RefreshEditor)

   451

   452

    def GetVariableLocationTree(self):

   453

        '''

   454

        This function is meant to be overridden by confnodes.

   455

   456

        It should returns an list of dictionaries

   457

   458

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

   459

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

   460

        '''

   461

        children = []

   462

        for child in self.IECSortedChildren():

   463

            children.append(child.GetVariableLocationTree())

   464

        return children

   465

   466

    def ConfNodePath(self):

   467

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

   468

   469

    def CTNPath(self, CTNName=None):

   470

        return self.ProjectPath

   471

   472

    def ConfNodeXmlFilePath(self, CTNName=None):

   473

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

   474

   475

    def ParentsTypesFactory(self):

   476

        return self.ConfNodeTypesFactory()

   477

   478

    def _setBuildPath(self, buildpath):

   479

        if CheckPathPerm(buildpath):

   480

            self.BuildPath = buildpath

   481

        else:

   482

            self.BuildPath = None

   483

        self.BuildPath = buildpath