1

"""

     2

Base definitions for beremiz confnodes

     3

"""

     4

     5

import os,sys,traceback

     6

import time

     7

import features

     8

import shutil

     9

import wx

    12

from time import localtime

    13

from datetime import datetime

    22

from TextViewer import TextViewer

    24

from targets.typemapping import DebugTypesSize

    25

from discovery import DiscoveryDialog

    29

    30

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

    31

    32

DEBUG_RETRIES_WARN = 3

    33

DEBUG_RETRIES_REREGISTER = 4

    34

    36

    """

    37

    This class define Root object of the confnode tree. 

    38

    It is responsible of :

    39

    - Managing project directory

    40

    - Building project

    41

    - Handling PLCOpenEditor controler and view

    42

    - Loading user confnodes and instanciante them as children

    43

    - ...

    44

    45

    """

    46

    47

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

    49

    50

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

    51

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

    52

      <xsd:element name="BeremizRoot">

    53

        <xsd:complexType>

    54

          <xsd:sequence>

    55

            <xsd:element name="TargetType">

    56

              <xsd:complexType>

    57

                <xsd:choice minOccurs="0">

    58

                """+targets.targetchoices+"""

    59

                </xsd:choice>

    60

              </xsd:complexType>

    61

            </xsd:element>

    62

          </xsd:sequence>

    63

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

    64

          <xsd:attribute name="Enable_ConfNodes" type="xsd:boolean" use="optional" default="true"/>

    65

        </xsd:complexType>

    66

      </xsd:element>

    67

    </xsd:schema>

    68

    """

    69

    70

    def __init__(self, frame, logger):

    71

        PLCControler.__init__(self)

    72

    73

        self.MandatoryParams = None

    74

        self.SetAppFrame(frame, logger)

    75

        self._builder = None

    76

        self._connector = None

    77

    79

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

    80

    81

        # Setup debug information

    82

        self.IECdebug_datas = {}

    83

        self.IECdebug_lock = Lock()

    84

    85

        self.DebugTimer=None

    86

        self.ResetIECProgramsAndVariables()

    87

    88

        #This method are not called here... but in NewProject and OpenProject

    89

        #self._AddParamsMembers()

    90

        #self.Children = {}

    91

    92

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

    93

        self.ChangesToSave = False

    94

        # root have no parent

    95

        self.CTNParent = None

    96

        # Keep track of the confnode type name

    97

        self.CTNType = "Beremiz"

    98

        self.Children = {}

    99

        # After __init__ root confnode is not valid

   100

        self.ProjectPath = None

   101

        self._setBuildPath(None)

   102

        self.DebugThread = None

   103

        self.debug_break = False

   104

        self.previous_plcstate = None

   105

        # copy ConfNodeMethods so that it can be later customized

   106

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

   107

        self.LoadSTLibrary()

   108

   109

    def __del__(self):

   110

        if self.DebugTimer:

   111

            self.DebugTimer.cancel()

   112

        self.KillDebugThread()

   113

   114

    def SetAppFrame(self, frame, logger):

   115

        self.AppFrame = frame

   116

        self.logger = logger

   117

        self.StatusTimer = None

   118

   119

        if frame is not None:

   120

            # Timer to pull PLC status

   121

            ID_STATUSTIMER = wx.NewId()

   122

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

   123

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

   124

   125

            self.RefreshConfNodesBlockLists()

   126

   127

    def ResetAppFrame(self, logger):

   128

        if self.AppFrame is not None:

   129

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

   130

            self.StatusTimer = None

   131

            self.AppFrame = None

   132

   133

        self.logger = logger

   134

   135

    def ConfNodeLibraryFilePath(self):

   136

        return os.path.join(os.path.split(__file__)[0], "pous.xml")

   137

   138

    def CTNTestModified(self):

   139

         return self.ChangesToSave or not self.ProjectIsSaved()

   140

   141

    def CTNFullName(self):

   142

        return ""

   143

   144

    def GetCTRoot(self):

   145

        return self

   146

   147

    def GetIECLibPath(self):

   148

        return self.ieclib_path

   149

   150

    def GetIEC2cPath(self):

   151

        return self.iec2c_path

   152

   153

    def GetCurrentLocation(self):

   154

        return ()

   155

   156

    def GetCurrentName(self):

   157

        return ""

   158

   159

    def _GetCurrentName(self):

   160

        return ""

   161

   162

    def GetProjectPath(self):

   163

        return self.ProjectPath

   164

   165

    def GetProjectName(self):

   166

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

   167

   168

    def GetDefaultTargetName(self):

   169

        if wx.Platform == '__WXMSW__':

   170

            return "Win32"

   171

        else:

   172

            return "Linux"

   173

   174

    def GetTarget(self):

   175

        target = self.BeremizRoot.getTargetType()

   176

        if target.getcontent() is None:

   177

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

   178

            target_name = self.GetDefaultTargetName()

   179

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

   180

        return target

   181

   182

    def GetParamsAttributes(self, path = None):

   183

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   184

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

   185

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

   186

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

   187

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

   188

        return params

   189

   190

    def SetParamsAttribute(self, path, value):

   191

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

   192

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

   193

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   194

   195

    # helper func to check project path write permission

   196

    def CheckProjectPathPerm(self, dosave=True):

   197

        if CheckPathPerm(self.ProjectPath):

   198

            return True

   199

        dialog = wx.MessageDialog(self.AppFrame, 

   200

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

   201

                    _('Error'), 

   202

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

   203

        answer = dialog.ShowModal()

   204

        dialog.Destroy()

   205

        if answer == wx.ID_YES:

   206

            if self.SaveProjectAs():

   207

                self.AppFrame.RefreshAll()

   208

                self.AppFrame.RefreshTitle()

   209

                self.AppFrame.RefreshFileMenu()

   210

                return True

   211

        return False

   212

   213

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

   214

        """

   215

        Create a new project in an empty folder

   216

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

   217

        @param PLCParams: properties of the PLCOpen program created

   218

        """

   219

        # Verify that chosen folder is empty

   220

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

   221

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

   222

   223

        dialog = ProjectDialog(self.AppFrame)

   224

        if dialog.ShowModal() == wx.ID_OK:

   225

            values = dialog.GetValues()

   226

            values["creationDateTime"] = datetime(*localtime()[:6])

   227

            dialog.Destroy()

   228

        else:

   229

            dialog.Destroy()

   230

            return _("Project not created")

   231

   232

        # Create PLCOpen program

   233

        self.CreateNewProject(values)

   234

        # Change XSD into class members

   235

        self._AddParamsMembers()

   236

        self.Children = {}

   237

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

   238

        self.ProjectPath = ProjectPath

   239

        self._setBuildPath(BuildPath)

   240

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

   241

        self.RefreshConfNodesBlockLists()

   242

        # this will create files base XML files

   243

        self.SaveProject()

   244

        return None

   245

   246

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

   247

        """

   248

        Load a project contained in a folder

   249

        @param ProjectPath: path of the project folder

   250

        """

   251

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

   252

            ProjectPath = os.path.dirname(ProjectPath)

   253

		# Verify that project contains a PLCOpen program

   254

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

   255

        if not os.path.isfile(plc_file):

   256

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

   257

        # Load PLCOpen file

   258

        result = self.OpenXMLFile(plc_file)

   259

        if result:

   260

            return result

   261

        # Change XSD into class members

   262

        self._AddParamsMembers()

   263

        self.Children = {}

   264

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

   265

        self.ProjectPath = ProjectPath

   266

        self._setBuildPath(BuildPath)

   267

        # If dir have already be made, and file exist

   268

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

   269

            #Load the confnode.xml file into parameters members

   270

            result = self.LoadXMLParams()

   271

            if result:

   272

                return result

   273

            #Load and init all the children

   274

            self.LoadChildren()

   275

        self.RefreshConfNodesBlockLists()

   276

   277

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

   278

            self.EnableMethod("_Clean", True)

   279

   280

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

   281

            self.ShowMethod("_showIECcode", True)

   282

   283

        return None

   284

   285

    def CloseProject(self):

   286

        self.ClearChildren()

   287

        self.ResetAppFrame(None)

   288

   289

    def SaveProject(self):

   290

        if self.CheckProjectPathPerm(False):

   291

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

   292

            result = self.CTNRequestSave()

   293

            if result:

   294

                self.logger.write_error(result)

   295

   296

    def SaveProjectAs(self, dosave=True):

   297

        # Ask user to choose a path with write permissions

   298

        if wx.Platform == '__WXMSW__':

   299

            path = os.getenv("USERPROFILE")

   300

        else:

   301

            path = os.getenv("HOME")

   302

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

   303

        answer = dirdialog.ShowModal()

   304

        dirdialog.Destroy()

   305

        if answer == wx.ID_OK:

   306

            newprojectpath = dirdialog.GetPath()

   307

            if os.path.isdir(newprojectpath):

   308

                self.ProjectPath = newprojectpath

   309

                if dosave:

   310

                    self.SaveProject()

   311

                self._setBuildPath(self.BuildPath)

   312

                return True

   313

        return False

   314

   315

    # Update PLCOpenEditor ConfNode Block types from loaded confnodes

   316

    def RefreshConfNodesBlockLists(self):

   317

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

   318

            self.ClearConfNodeTypes()

   319

            self.AddConfNodeTypesList(self.ConfNodesTypesFactory())

   320

        if self.AppFrame is not None:

   321

            self.AppFrame.RefreshLibraryPanel()

   322

            self.AppFrame.RefreshEditor()

   323

   324

    # Update a PLCOpenEditor Pou variable location

   325

    def UpdateProjectVariableLocation(self, old_leading, new_leading):

   326

        self.Project.updateElementAddress(old_leading, new_leading)

   327

        self.BufferProject()

   328

        if self.AppFrame is not None:

   329

            self.AppFrame.RefreshTitle()

   330

            self.AppFrame.RefreshInstancesTree()

   331

            self.AppFrame.RefreshFileMenu()

   332

            self.AppFrame.RefreshEditMenu()

   333

            self.AppFrame.RefreshEditor()

   334

   335

    def GetVariableLocationTree(self):

   336

        '''

   337

        This function is meant to be overridden by confnodes.

   338

   339

        It should returns an list of dictionaries

   340

   341

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

   342

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

   343

        '''

   344

        children = []

   345

        for child in self.IECSortedChildren():

   346

            children.append(child.GetVariableLocationTree())

   347

        return children

   348

   349

    def ConfNodePath(self):

   350

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

   351

   352

    def CTNPath(self, CTNName=None):

   353

        return self.ProjectPath

   354

   355

    def ConfNodeXmlFilePath(self, CTNName=None):

   356

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

   357

   358

    def ParentsTypesFactory(self):

   359

        return self.ConfNodeTypesFactory()

   360

   361

    def _setBuildPath(self, buildpath):

   362

        if CheckPathPerm(buildpath):

   363

            self.BuildPath = buildpath

   364

        else:

   365

            self.BuildPath = None

   366

        self.BuildPath = buildpath

   367

        self.DefaultBuildPath = None

   368

        if self._builder is not None:

   369

            self._builder.SetBuildPath(self._getBuildPath())

   370

   371

    def _getBuildPath(self):

   372

        # BuildPath is defined by user

   373

        if self.BuildPath is not None:

   374

            return self.BuildPath

   375

        # BuildPath isn't defined by user but already created by default

   376

        if self.DefaultBuildPath is not None:

   377

            return self.DefaultBuildPath

   378

        # Create a build path in project folder if user has permissions

   379

        if CheckPathPerm(self.ProjectPath):

   380

            self.DefaultBuildPath = os.path.join(self.ProjectPath, "build")

   381

        # Create a build path in temp folder

   382

        else:

   383

            self.DefaultBuildPath = os.path.join(tempfile.mkdtemp(), os.path.basename(self.ProjectPath), "build")

   384

   385

        if not os.path.exists(self.DefaultBuildPath):

   386

            os.makedirs(self.DefaultBuildPath)

   387

        return self.DefaultBuildPath

   388

   389

    def _getExtraFilesPath(self):

   390

        return os.path.join(self._getBuildPath(), "extra_files")

   391

   392

    def _getIECcodepath(self):

   393

        # define name for IEC code file

   394

        return os.path.join(self._getBuildPath(), "plc.st")

   395

   396

    def _getIECgeneratedcodepath(self):

   397

        # define name for IEC generated code file

   398

        return os.path.join(self._getBuildPath(), "generated_plc.st")

   399

   400

    def _getIECrawcodepath(self):

   401

        # define name for IEC raw code file

   402

        return os.path.join(self.CTNPath(), "raw_plc.st")

   403

   404

    def GetLocations(self):

   405

        locations = []

   406

        filepath = os.path.join(self._getBuildPath(),"LOCATED_VARIABLES.h")

   407

        if os.path.isfile(filepath):

   408

            # IEC2C compiler generate a list of located variables : LOCATED_VARIABLES.h

   409

            location_file = open(os.path.join(self._getBuildPath(),"LOCATED_VARIABLES.h"))

   410

            # each line of LOCATED_VARIABLES.h declares a located variable

   411

            lines = [line.strip() for line in location_file.readlines()]

   412

            # This regular expression parses the lines genereated by IEC2C

   413

            LOCATED_MODEL = re.compile("__LOCATED_VAR\((?P<IEC_TYPE>[A-Z]*),(?P<NAME>[_A-Za-z0-9]*),(?P<DIR>[QMI])(?:,(?P<SIZE>[XBWDL]))?,(?P<LOC>[,0-9]*)\)")

   414

            for line in lines:

   415

                # If line match RE, 

   416

                result = LOCATED_MODEL.match(line)

   417

                if result:

   418

                    # Get the resulting dict

   419

                    resdict = result.groupdict()

   420

                    # rewrite string for variadic location as a tuple of integers

   421

                    resdict['LOC'] = tuple(map(int,resdict['LOC'].split(',')))

   422

                    # set located size to 'X' if not given 

   423

                    if not resdict['SIZE']:

   424

                        resdict['SIZE'] = 'X'

   425

                    # finally store into located variable list

   426

                    locations.append(resdict)

   427

        return locations

   428

   429

    def _Generate_SoftPLC(self):

   430

        """

   431

        Generate SoftPLC ST/IL/SFC code out of PLCOpenEditor controller, and compile it with IEC2C

   432

        @param buildpath: path where files should be created

   433

        """

   434

   435

        # Update PLCOpenEditor ConfNode Block types before generate ST code

   436

        self.RefreshConfNodesBlockLists()

   437

   438

        self.logger.write(_("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n"))

   439

        buildpath = self._getBuildPath()

   440

        # ask PLCOpenEditor controller to write ST/IL/SFC code file

   441

        program, errors, warnings = self.GenerateProgram(self._getIECgeneratedcodepath())

   442

        if len(warnings) > 0:

   443

            self.logger.write_warning(_("Warnings in ST/IL/SFC code generator :\n"))

   444

            for warning in warnings:

   445

                self.logger.write_warning("%s\n"%warning)

   446

        if len(errors) > 0:

   447

            # Failed !

   448

            self.logger.write_error(_("Error in ST/IL/SFC code generator :\n%s\n")%errors[0])

   449

            return False

   450

        plc_file = open(self._getIECcodepath(), "w")

   451

        # Add ST Library from confnodes

   452

        plc_file.write(self.ConfNodesSTLibraryFactory())

   453

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

   454

            plc_file.write(open(self._getIECrawcodepath(), "r").read())

   455

            plc_file.write("\n")

   456

        plc_file.close()

   457

        plc_file = open(self._getIECcodepath(), "r")

   458

        self.ProgramOffset = 0

   459

        for line in plc_file.xreadlines():

   460

            self.ProgramOffset += 1

   461

        plc_file.close()

   462

        plc_file = open(self._getIECcodepath(), "a")

   463

        plc_file.write(open(self._getIECgeneratedcodepath(), "r").read())

   464

        plc_file.close()

   465

   466

        self.logger.write(_("Compiling IEC Program into C code...\n"))

   467

   468

        # Now compile IEC code into many C files

   469

        # files are listed to stdout, and errors to stderr. 

   470

        status, result, err_result = ProcessLogger(

   471

               self.logger,

   472

               "\"%s\" -f -I \"%s\" -T \"%s\" \"%s\""%(

   473

                         self.iec2c_path,

   474

                         self.ieclib_path, 

   475

                         buildpath,

   476

                         self._getIECcodepath()),

   477

               no_stdout=True, no_stderr=True).spin()

   478

        if status:

   479

            # Failed !

   480

   481

            # parse iec2c's error message. if it contains a line number,

   482

            # then print those lines from the generated IEC file.

   483

            for err_line in err_result.split('\n'):