1 """

     2 Base definitions for beremiz confnodes

     3 """

     4 

     5 import os,sys,traceback

     6 import time

     7 import features

     8 import types

     9 import shutil

    10 from xml.dom import minidom

    11 import wx

    12 

    13 #Quick hack to be able to find Beremiz IEC tools. Should be config params.

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

    15 

    16 from xmlclass import GenerateClassesFromXSDstring

    17 from ProcessLogger import ProcessLogger

    18 

    19 from PLCControler import PLCControler, LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    20 

    21 _BaseParamsClass = GenerateClassesFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

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

    23           <xsd:element name="BaseParams">

    24             <xsd:complexType>

    25               <xsd:attribute name="Name" type="xsd:string" use="optional" default="__unnamed__"/>

    26               <xsd:attribute name="IEC_Channel" type="xsd:integer" use="required"/>

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

    28             </xsd:complexType>

    29           </xsd:element>

    30         </xsd:schema>""")["BaseParams"]

    31 

    32 NameTypeSeparator = '@'

    33 

    34 class MiniTextControler:

    35     

    36     def __init__(self, filepath):

    37         self.FilePath = filepath

    38     

    39     def CTNFullName(self):

    40         return ""

    41     

    42     def SetEditedElementText(self, tagname, text):

    43         file = open(self.FilePath, "w")

    44         file.write(text)

    45         file.close()

    46         

    47     def GetEditedElementText(self, tagname, debug = False):

    48         if os.path.isfile(self.FilePath):

    49             file = open(self.FilePath, "r")

    50             text = file.read()

    51             file.close()

    52             return text

    53         return ""

    54     

    55     def GetEditedElementInterfaceVars(self, tagname, debug = False):

    56         return []

    57     

    58     def GetEditedElementType(self, tagname, debug = False):

    59         return "program"

    60     

    61     def GetBlockTypes(self, tagname = "", debug = False):

    62         return []

    63     

    64     def GetDataTypes(self, tagname = "", basetypes = True, only_locatables = False, debug = False):

    65         return []

    66     

    67     def GetEnumeratedDataValues(self, debug = False):

    68         return []

    69     

    70     def StartBuffering(self):

    71         pass

    72 

    73     def EndBuffering(self):

    74         pass

    75 

    76     def BufferProject(self):

    77         pass

    78 

    79 # helper func to get path to images

    80 def opjimg(imgname):

    81     return os.path.join(base_folder, "beremiz", "images",imgname)

    82     

    83 # helper func to check path write permission

    84 def CheckPathPerm(path):

    85     if path is None or not os.path.isdir(path):

    86         return False

    87     for root, dirs, files in os.walk(path):

    88          for name in files:

    89              if os.access(root, os.W_OK) is not True or os.access(os.path.join(root, name), os.W_OK) is not True:

    90                  return False

    91     return True

    92     

    93 class ConfigTreeNode:

    94     """

    95     This class is the one that define confnodes.

    96     """

    97 

    98     XSD = None

    99     CTNChildrenTypes = []

   100     CTNMaxCount = None

   101     ConfNodeMethods = []

   102     LibraryControler = None

   103     EditorType = None

   104 

   105     def _AddParamsMembers(self):

   106         self.CTNParams = None

   107         if self.XSD:

   108             self.Classes = GenerateClassesFromXSDstring(self.XSD)

   109             Classes = [(name, XSDclass) for name, XSDclass in self.Classes.items() if XSDclass.IsBaseClass]

   110             if len(Classes) == 1:

   111                 name, XSDclass = Classes[0]

   112                 obj = XSDclass()

   113                 self.CTNParams = (name, obj)

   114                 setattr(self, name, obj)

   115 

   116     def __init__(self):

   117         # Create BaseParam 

   118         self.BaseParams = _BaseParamsClass()

   119         self.MandatoryParams = ("BaseParams", self.BaseParams)

   120         self._AddParamsMembers()

   121         self.Children = {}

   122         self._View = None

   123         # copy ConfNodeMethods so that it can be later customized

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

   125         self.LoadSTLibrary()

   126         

   127     def ConfNodeBaseXmlFilePath(self, CTNName=None):

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

   129     

   130     def ConfNodeXmlFilePath(self, CTNName=None):

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

   132 

   133     def ConfNodeLibraryFilePath(self):

   134         return os.path.join(self.ConfNodePath(), "pous.xml")

   135 

   136     def ConfNodePath(self):

   137         return os.path.join(self.CTNParent.ConfNodePath(), self.CTNType)

   138 

   139     def CTNPath(self,CTNName=None):

   140         if not CTNName:

   141             CTNName = self.CTNName()

   142         return os.path.join(self.CTNParent.CTNPath(),

   143                             CTNName + NameTypeSeparator + self.CTNType)

   144     

   145     def CTNName(self):

   146         return self.BaseParams.getName()

   147     

   148     def CTNEnabled(self):

   149         return self.BaseParams.getEnabled()

   150     

   151     def CTNFullName(self):

   152         parent = self.CTNParent.CTNFullName()

   153         if parent != "":

   154             return parent + "." + self.CTNName()

   155         return self.BaseParams.getName()

   156     

   157     def GetIconPath(self, name):

   158         return opjimg(name)

   159     

   160     def CTNTestModified(self):

   161         return self.ChangesToSave

   162 

   163     def ProjectTestModified(self):

   164         """

   165         recursively check modified status

   166         """

   167         if self.CTNTestModified():

   168             return True

   169 

   170         for CTNChild in self.IterChildren():

   171             if CTNChild.ProjectTestModified():

   172                 return True

   173 

   174         return False

   175     

   176     def RemoteExec(self, script, **kwargs):

   177         return self.CTNParent.RemoteExec(script, **kwargs)

   178     

   179     def OnCTNSave(self):

   180         #Default, do nothing and return success

   181         return True

   182 

   183     def GetParamsAttributes(self, path = None):

   184         if path:

   185             parts = path.split(".", 1)

   186             if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   187                 return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

   188             elif self.CTNParams and parts[0] == self.CTNParams[0]:

   189                 return self.CTNParams[1].getElementInfos(parts[0], parts[1])

   190         else:

   191             params = []

   192             if wx.VERSION < (2, 8, 0) and self.MandatoryParams:

   193                 params.append(self.MandatoryParams[1].getElementInfos(self.MandatoryParams[0]))

   194             if self.CTNParams:

   195                 params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))

   196             return params

   197         

   198     def SetParamsAttribute(self, path, value):

   199         self.ChangesToSave = True

   200         # Filter IEC_Channel and Name, that have specific behavior

   201         if path == "BaseParams.IEC_Channel":

   202             old_leading = ".".join(map(str, self.GetCurrentLocation()))

   203             new_value = self.FindNewIEC_Channel(value)

   204             new_leading = ".".join(map(str, self.CTNParent.GetCurrentLocation() + (new_value,)))

   205             self.GetCTRoot().UpdateProjectVariableLocation(old_leading, new_leading)

   206             return new_value, True

   207         elif path == "BaseParams.Name":

   208             res = self.FindNewName(value)

   209             self.CTNRequestSave()

   210             return res, True

   211         

   212         parts = path.split(".", 1)

   213         if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   214             self.MandatoryParams[1].setElementValue(parts[1], value)

   215         elif self.CTNParams and parts[0] == self.CTNParams[0]:

   216             self.CTNParams[1].setElementValue(parts[1], value)

   217         return value, False

   218 

   219     def CTNMakeDir(self):

   220         os.mkdir(self.CTNPath())

   221 

   222     def CTNRequestSave(self):

   223         if self.GetCTRoot().CheckProjectPathPerm(False):

   224             # If confnode do not have corresponding directory

   225             ctnpath = self.CTNPath()

   226             if not os.path.isdir(ctnpath):

   227                 # Create it

   228                 os.mkdir(ctnpath)

   229     

   230             # generate XML for base XML parameters controller of the confnode

   231             if self.MandatoryParams:

   232                 BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(),'w')

   233                 BaseXMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

   234                 BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0).encode("utf-8"))

   235                 BaseXMLFile.close()

   236             

   237             # generate XML for XML parameters controller of the confnode

   238             if self.CTNParams:

   239                 XMLFile = open(self.ConfNodeXmlFilePath(),'w')

   240                 XMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

   241                 XMLFile.write(self.CTNParams[1].generateXMLText(self.CTNParams[0], 0).encode("utf-8"))

   242                 XMLFile.close()

   243             

   244             # Call the confnode specific OnCTNSave method

   245             result = self.OnCTNSave()

   246             if not result:

   247                 return _("Error while saving \"%s\"\n")%self.CTNPath()

   248     

   249             # mark confnode as saved

   250             self.ChangesToSave = False

   251             # go through all children and do the same

   252             for CTNChild in self.IterChildren():

   253                 result = CTNChild.CTNRequestSave()

   254                 if result:

   255                     return result

   256         return None

   257     

   258     def CTNImport(self, src_CTNPath):

   259         shutil.copytree(src_CTNPath, self.CTNPath)

   260         return True

   261 

   262     def CTNGenerate_C(self, buildpath, locations):

   263         """

   264         Generate C code

   265         @param locations: List of complete variables locations \

   266             [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   267             "NAME" : name of the variable (generally "__IW0_1_2" style)

   268             "DIR" : direction "Q","I" or "M"

   269             "SIZE" : size "X", "B", "W", "D", "L"

   270             "LOC" : tuple of interger for IEC location (0,1,2,...)

   271             }, ...]

   272         @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   273         """

   274         self.GetCTRoot().logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")

   275         return [],"",False

   276     

   277     def _Generate_C(self, buildpath, locations):

   278         # Generate confnodes [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files

   279         # extra_files = [(fname,fobject), ...]

   280         gen_result = self.CTNGenerate_C(buildpath, locations)

   281         CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   282         extra_files = gen_result[3:]

   283         # if some files have been generated put them in the list with their location

   284         if CTNCFilesAndCFLAGS:

   285             LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), CTNCFilesAndCFLAGS, DoCalls)]

   286         else:

   287             LocationCFilesAndCFLAGS = []

   288 

   289         # confnode asks for some LDFLAGS

   290         if CTNLDFLAGS:

   291             # LDFLAGS can be either string

   292             if type(CTNLDFLAGS)==type(str()):

   293                 LDFLAGS=[CTNLDFLAGS]

   294             #or list of strings

   295             elif type(CTNLDFLAGS)==type(list()):

   296                 LDFLAGS=CTNLDFLAGS[:]

   297         else:

   298             LDFLAGS=[]

   299         

   300         # recurse through all children, and stack their results

   301         for CTNChild in self.IECSortedChildren():

   302             new_location = CTNChild.GetCurrentLocation()

   303             # How deep are we in the tree ?

   304             depth=len(new_location)

   305             _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   306                 CTNChild._Generate_C(

   307                     #keep the same path

   308                     buildpath,

   309                     # filter locations that start with current IEC location

   310                     [loc for loc in locations if loc["LOC"][0:depth] == new_location ])

   311             # stack the result

   312             LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   313             LDFLAGS += _LDFLAGS

   314             extra_files += _extra_files

   315         

   316         return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   317 

   318     def ConfNodeTypesFactory(self):

   319         if self.LibraryControler is not None:

   320             return [{"name" : self.CTNType, "types": self.LibraryControler.Project}]

   321         return []

   322 

   323     def ParentsTypesFactory(self):

   324         return self.CTNParent.ParentsTypesFactory() + self.ConfNodeTypesFactory()

   325 

   326     def ConfNodesTypesFactory(self):

   327         list = self.ConfNodeTypesFactory()

   328         for CTNChild in self.IterChildren():

   329             list += CTNChild.ConfNodesTypesFactory()

   330         return list

   331 

   332     def STLibraryFactory(self):

   333         if self.LibraryControler is not None:

   334             program, errors, warnings = self.LibraryControler.GenerateProgram()

   335             return program + "\n"

   336         return ""

   337 

   338     def ConfNodesSTLibraryFactory(self):

   339         program = self.STLibraryFactory()

   340         for CTNChild in self.IECSortedChildren():

   341             program += CTNChild.ConfNodesSTLibraryFactory()

   342         return program

   343         

   344     def IterChildren(self):

   345         for CTNType, Children in self.Children.items():

   346             for CTNInstance in Children:

   347                 yield CTNInstance

   348     

   349     def IECSortedChildren(self):

   350         # reorder children by IEC_channels

   351         ordered = [(chld.BaseParams.getIEC_Channel(),chld) for chld in self.IterChildren()]

   352         if ordered:

   353             ordered.sort()

   354             return zip(*ordered)[1]

   355         else:

   356             return []

   357     

   358     def _GetChildBySomething(self, something, toks):

   359         for CTNInstance in self.IterChildren():

   360             # if match component of the name

   361             if getattr(CTNInstance.BaseParams, something) == toks[0]:

   362                 # if Name have other components

   363                 if len(toks) >= 2:

   364                     # Recurse in order to find the latest object

   365                     return CTNInstance._GetChildBySomething( something, toks[1:])

   366                 # No sub name -> found

   367                 return CTNInstance

   368         # Not found

   369         return None

   370 

   371     def GetChildByName(self, Name):

   372         if Name:

   373             toks = Name.split('.')

   374             return self._GetChildBySomething("Name", toks)

   375         else:

   376             return self

   377 

   378     def GetChildByIECLocation(self, Location):

   379         if Location:

   380             return self._GetChildBySomething("IEC_Channel", Location)

   381         else:

   382             return self

   383     

   384     def GetCurrentLocation(self):

   385         """

   386         @return:  Tupple containing confnode IEC location of current confnode : %I0.0.4.5 => (0,0,4,5)

   387         """

   388         return self.CTNParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)

   389 

   390     def GetCurrentName(self):

   391         """

   392         @return:  String "ParentParentName.ParentName.Name"

   393         """

   394         return  self.CTNParent._GetCurrentName() + self.BaseParams.getName()

   395 

   396     def _GetCurrentName(self):

   397         """

   398         @return:  String "ParentParentName.ParentName.Name."

   399         """

   400         return  self.CTNParent._GetCurrentName() + self.BaseParams.getName() + "."

   401 

   402     def GetCTRoot(self):

   403         return self.CTNParent.GetCTRoot()

   404 

   405     def GetFullIEC_Channel(self):

   406         return ".".join([str(i) for i in self.GetCurrentLocation()]) + ".x"

   407 

   408     def GetLocations(self):

   409         location = self.GetCurrentLocation()

   410         return [loc for loc in self.CTNParent.GetLocations() if loc["LOC"][0:len(location)] == location]

   411 

   412     def GetVariableLocationTree(self):

   413         '''

   414         This function is meant to be overridden by confnodes.

   415 

   416         It should returns an list of dictionaries

   417         

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

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

   420         '''

   421         children = []

   422         for child in self.IECSortedChildren():

   423             children.append(child.GetVariableLocationTree())

   424         return {"name": self.BaseParams.getName(),

   425                 "type": LOCATION_CONFNODE,

   426                 "location": self.GetFullIEC_Channel(),

   427                 "children": children}

   428 

   429     def FindNewName(self, DesiredName):

   430         """

   431         Changes Name to DesiredName if available, Name-N if not.

   432         @param DesiredName: The desired Name (string)

   433         """

   434         # Get Current Name

   435         CurrentName = self.BaseParams.getName()

   436         # Do nothing if no change

   437         #if CurrentName == DesiredName: return CurrentName

   438         # Build a list of used Name out of parent's Children

   439         AllNames=[]

   440         for CTNInstance in self.CTNParent.IterChildren():

   441             if CTNInstance != self:

   442                 AllNames.append(CTNInstance.BaseParams.getName())

   443 

   444         # Find a free name, eventually appending digit

   445         res = DesiredName

   446         suffix = 1

   447         while res in AllNames:

   448             res = "%s-%d"%(DesiredName, suffix)

   449             suffix += 1

   450         

   451         # Get old path

   452         oldname = self.CTNPath()

   453         # Check previous confnode existance

   454         dontexist = self.BaseParams.getName() == "__unnamed__"

   455         # Set the new name

   456         self.BaseParams.setName(res)

   457         # Rename confnode dir if exist

   458         if not dontexist:

   459             shutil.move(oldname, self.CTNPath())

   460         # warn user he has two left hands

   461         if DesiredName != res:

   462             self.GetCTRoot().logger.write_warning(_("A child names \"%s\" already exist -> \"%s\"\n")%(DesiredName,res))

   463         return res

   464 

   465     def GetAllChannels(self):

   466         AllChannels=[]

   467         for CTNInstance in self.CTNParent.IterChildren():

   468             if CTNInstance != self:

   469                 AllChannels.append(CTNInstance.BaseParams.getIEC_Channel())

   470         AllChannels.sort()

   471         return AllChannels

   472 

   473     def FindNewIEC_Channel(self, DesiredChannel):

   474         """

   475         Changes IEC Channel number to DesiredChannel if available, nearest available if not.

   476         @param DesiredChannel: The desired IEC channel (int)

   477         """

   478         # Get Current IEC channel

   479         CurrentChannel = self.BaseParams.getIEC_Channel()

   480         # Do nothing if no change

   481         #if CurrentChannel == DesiredChannel: return CurrentChannel

   482         # Build a list of used Channels out of parent's Children

   483         AllChannels = self.GetAllChannels()

   484         

   485         # Now, try to guess the nearest available channel

   486         res = DesiredChannel

   487         while res in AllChannels: # While channel not free

   488             if res < CurrentChannel: # Want to go down ?

   489                 res -=  1 # Test for n-1

   490                 if res < 0 :

   491                     self.GetCTRoot().logger.write_warning(_("Cannot find lower free IEC channel than %d\n")%CurrentChannel)

   492                     return CurrentChannel # Can't go bellow 0, do nothing

   493             else : # Want to go up ?

   494                 res +=  1 # Test for n-1

   495         # Finally set IEC Channel

   496         self.BaseParams.setIEC_Channel(res)

   497         return res

   498 

   499     def _OpenView(self, name=None):

   500         if self.EditorType is not None and self._View is None:

   501             app_frame = self.GetCTRoot().AppFrame

   502             

   503             self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)

   504             

   505             app_frame.EditProjectElement(self._View, self.CTNName())

   506             

   507             return self._View

   508         return None

   509 

   510     def OnCloseEditor(self, view):

   511         if self._View == view:

   512             self._View = None

   513 

   514     def OnCTNClose(self):

   515         if self._View is not None:

   516             app_frame = self.GetCTRoot().AppFrame

   517             if app_frame is not None:

   518                 app_frame.DeletePage(self._View)

   519         return True

   520 

   521     def _doRemoveChild(self, CTNInstance):

   522         # Remove all children of child

   523         for SubCTNInstance in CTNInstance.IterChildren():

   524             CTNInstance._doRemoveChild(SubCTNInstance)

   525         # Call the OnCloseMethod

   526         CTNInstance.OnCTNClose()

   527         # Delete confnode dir

   528         shutil.rmtree(CTNInstance.CTNPath())

   529         # Remove child of Children

   530         self.Children[CTNInstance.CTNType].remove(CTNInstance)

   531         # Forget it... (View have to refresh)

   532 

   533     def CTNRemove(self):

   534         # Fetch the confnode

   535         #CTNInstance = self.GetChildByName(CTNName)

   536         # Ask to his parent to remove it

   537         self.CTNParent._doRemoveChild(self)

   538 

   539     def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):

   540         """

   541         Create the confnodes that may be added as child to this node self

   542         @param CTNType: string desining the confnode class name (get name from CTNChildrenTypes)

   543         @param CTNName: string for the name of the confnode instance

   544         """

   545         # reorganize self.CTNChildrenTypes tuples from (name, CTNClass, Help)

   546         # to ( name, (CTNClass, Help)), an make a dict

   547         transpose = zip(*self.CTNChildrenTypes)

   548         CTNChildrenTypes = dict(zip(transpose[0],zip(transpose[1],transpose[2])))

   549         # Check that adding this confnode is allowed

   550         try:

   551             CTNClass, CTNHelp = CTNChildrenTypes[CTNType]

   552         except KeyError:

   553             raise Exception, _("Cannot create child %s of type %s ")%(CTNName, CTNType)

   554         

   555         # if CTNClass is a class factory, call it. (prevent unneeded imports)

   556         if type(CTNClass) == types.FunctionType:

   557             CTNClass = CTNClass()

   558         

   559         # Eventualy Initialize child instance list for this class of confnode

   560         ChildrenWithSameClass = self.Children.setdefault(CTNType, list())

   561         # Check count

   562         if getattr(CTNClass, "CTNMaxCount", None) and len(ChildrenWithSameClass) >= CTNClass.CTNMaxCount:

   563             raise Exception, _("Max count (%d) reached for this confnode of type %s ")%(CTNClass.CTNMaxCount, CTNType)

   564         

   565         # create the final class, derived of provided confnode and template

   566         class FinalCTNClass(CTNClass, ConfigTreeNode):

   567             """

   568             ConfNode class is derivated into FinalCTNClass before being instanciated

   569             This way __init__ is overloaded to ensure ConfigTreeNode.__init__ is called 

   570             before CTNClass.__init__, and to do the file related stuff.

   571             """

   572             def __init__(_self):

   573                 # self is the parent

   574                 _self.CTNParent = self

   575                 # Keep track of the confnode type name

   576                 _self.CTNType = CTNType

   577                 # remind the help string, for more fancy display

   578                 _self.CTNHelp = CTNHelp

   579                 # Call the base confnode template init - change XSD into class members

   580                 ConfigTreeNode.__init__(_self)

   581                 # check name is unique

   582                 NewCTNName = _self.FindNewName(CTNName)

   583                 # If dir have already be made, and file exist

   584                 if os.path.isdir(_self.CTNPath(NewCTNName)): #and os.path.isfile(_self.ConfNodeXmlFilePath(CTNName)):

   585                     #Load the confnode.xml file into parameters members

   586                     _self.LoadXMLParams(NewCTNName)

   587                     # Basic check. Better to fail immediately.

   588                     if (_self.BaseParams.getName() != NewCTNName):

   589                         raise Exception, _("Project tree layout do not match confnode.xml %s!=%s ")%(NewCTNName, _self.BaseParams.getName())

   590 

   591                     # Now, self.CTNPath() should be OK

   592                     

   593                     # Check that IEC_Channel is not already in use.

   594                     _self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())

   595                     # Call the confnode real __init__

   596                     if getattr(CTNClass, "__init__", None):

   597                         CTNClass.__init__(_self)

   598                     #Load and init all the children

   599                     _self.LoadChildren()

   600                     #just loaded, nothing to saved

   601                     _self.ChangesToSave = False

   602                 else:

   603                     # If confnode do not have corresponding file/dirs - they will be created on Save

   604                     _self.CTNMakeDir()

   605                     # Find an IEC number

   606                     _self.FindNewIEC_Channel(IEC_Channel)

   607                     # Call the confnode real __init__

   608                     if getattr(CTNClass, "__init__", None):

   609                         CTNClass.__init__(_self)

   610                     _self.CTNRequestSave()

   611                     #just created, must be saved

   612                     _self.ChangesToSave = True

   613                 

   614             def _getBuildPath(_self):

   615                 return self._getBuildPath()

   616             

   617         # Create the object out of the resulting class

   618         newConfNodeOpj = FinalCTNClass()

   619         # Store it in CTNgedChils

   620         ChildrenWithSameClass.append(newConfNodeOpj)

   621         

   622         return newConfNodeOpj

   623     

   624     def ClearChildren(self):

   625         for child in self.IterChildren():

   626             child.ClearChildren()

   627         self.Children = {}

   628     

   629     def LoadSTLibrary(self):

   630         # Get library blocks if plcopen library exist

   631         library_path = self.ConfNodeLibraryFilePath()

   632         if os.path.isfile(library_path):

   633             self.LibraryControler = PLCControler()

   634             self.LibraryControler.OpenXMLFile(library_path)

   635             self.LibraryControler.ClearConfNodeTypes()

   636             self.LibraryControler.AddConfNodeTypesList(self.ParentsTypesFactory())

   637 

   638     def LoadXMLParams(self, CTNName = None):

   639         methode_name = os.path.join(self.CTNPath(CTNName), "methods.py")

   640         if os.path.isfile(methode_name):

   641             execfile(methode_name)

   642         

   643         # Get the base xml tree

   644         if self.MandatoryParams:

   645             try:

   646                 basexmlfile = open(self.ConfNodeBaseXmlFilePath(CTNName), 'r')

   647                 basetree = minidom.parse(basexmlfile)

   648                 self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])

   649                 basexmlfile.close()

   650             except Exception, exc:

   651                 self.GetCTRoot().logger.write_error(_("Couldn't load confnode base parameters %s :\n %s") % (CTNName, str(exc)))

   652                 self.GetCTRoot().logger.write_error(traceback.format_exc())

   653         

   654         # Get the xml tree

   655         if self.CTNParams:

   656             try:

   657                 xmlfile = open(self.ConfNodeXmlFilePath(CTNName), 'r')

   658                 tree = minidom.parse(xmlfile)

   659                 self.CTNParams[1].loadXMLTree(tree.childNodes[0])

   660                 xmlfile.close()

   661             except Exception, exc:

   662                 self.GetCTRoot().logger.write_error(_("Couldn't load confnode parameters %s :\n %s") % (CTNName, str(exc)))

   663                 self.GetCTRoot().logger.write_error(traceback.format_exc())

   664         

   665     def LoadChildren(self):

   666         # Iterate over all CTNName@CTNType in confnode directory, and try to open them

   667         for CTNDir in os.listdir(self.CTNPath()):

   668             if os.path.isdir(os.path.join(self.CTNPath(), CTNDir)) and \

   669                CTNDir.count(NameTypeSeparator) == 1:

   670                 pname, ptype = CTNDir.split(NameTypeSeparator)

   671                 try:

   672                     self.CTNAddChild(pname, ptype)

   673                 except Exception, exc:

   674                     self.GetCTRoot().logger.write_error(_("Could not add child \"%s\", type %s :\n%s\n")%(pname, ptype, str(exc)))

   675                     self.GetCTRoot().logger.write_error(traceback.format_exc())

   676 

   677     def EnableMethod(self, method, value):

   678         for d in self.ConfNodeMethods:

   679             if d["method"]==method:

   680                 d["enabled"]=value

   681                 return True

   682         return False

   683 

   684     def ShowMethod(self, method, value):

   685         for d in self.ConfNodeMethods:

   686             if d["method"]==method:

   687                 d["shown"]=value

   688                 return True

   689         return False

   690 

   691     def CallMethod(self, method):

   692         for d in self.ConfNodeMethods:

   693             if d["method"]==method and d.get("enabled", True) and d.get("shown", True):

   694                 getattr(self, method)()

   695 

   696 

   697 ####################################################################################

   698 ####################################################################################

   699 ####################################################################################

   700 ###################################   ROOT    ######################################

   701 ####################################################################################

   702 ####################################################################################

   703 ####################################################################################

   704 

   705 if wx.Platform == '__WXMSW__':

   706     exe_ext=".exe"

   707 else:

   708     exe_ext=""

   709 

   710 # import for project creation timestamping

   711 from threading import Timer, Lock, Thread, Semaphore

   712 from time import localtime

   713 from datetime import datetime

   714 # import necessary stuff from PLCOpenEditor

   715 from PLCOpenEditor import PLCOpenEditor, ProjectDialog

   716 from TextViewer import TextViewer

   717 from plcopen.structures import IEC_KEYWORDS, TypeHierarchy_list

   718 

   719 

   720 import re, tempfile

   721 import targets

   722 from targets.typemapping import DebugTypesSize

   723 

   724 import connectors

   725 from discovery import DiscoveryDialog

   726 from weakref import WeakKeyDictionary

   727 

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

   729 

   730 DEBUG_RETRIES_WARN = 3

   731 DEBUG_RETRIES_REREGISTER = 4

   732 

   733 def CTNClassFactory(classpath):

   734     if type(classpath)==str:

   735         def fac():

   736             mod=__import__(classpath.rsplit('.',1)[0])

   737             return reduce(getattr, classpath.split('.')[1:], mod)

   738         return fac

   739     else:

   740         return lambda:classpath

   741 

   742 class ConfigTreeRoot(ConfigTreeNode, PLCControler):

   743     """

   744     This class define Root object of the confnode tree. 

   745     It is responsible of :

   746     - Managing project directory

   747     - Building project

   748     - Handling PLCOpenEditor controler and view

   749     - Loading user confnodes and instanciante them as children

   750     - ...

   751     

   752     """

   753 

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

   755     CTNChildrenTypes =  [(n, CTNClassFactory(c), d) for n,d,h,c in features.catalog]

   756 

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

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

   759       <xsd:element name="BeremizRoot">

   760         <xsd:complexType>

   761           <xsd:sequence>

   762             <xsd:element name="TargetType">

   763               <xsd:complexType>

   764                 <xsd:choice minOccurs="0">

   765                 """+targets.targetchoices+"""

   766                 </xsd:choice>

   767               </xsd:complexType>

   768             </xsd:element>

   769           </xsd:sequence>

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

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

   772         </xsd:complexType>

   773       </xsd:element>

   774     </xsd:schema>

   775     """

   776 

   777     def __init__(self, frame, logger):

   778         PLCControler.__init__(self)

   779 

   780         self.MandatoryParams = None

   781         self.SetAppFrame(frame, logger)

   782         self._builder = None

   783         self._connector = None

   784         

   785         self.iec2c_path = os.path.join(base_folder, "matiec", "iec2c"+exe_ext)

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

   787         

   788         # Setup debug information

   789         self.IECdebug_datas = {}

   790         self.IECdebug_lock = Lock()

   791 

   792         self.DebugTimer=None

   793         self.ResetIECProgramsAndVariables()

   794         

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

   796         #self._AddParamsMembers()

   797         #self.Children = {}

   798 

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

   800         self.ChangesToSave = False

   801         # root have no parent

   802         self.CTNParent = None

   803         # Keep track of the confnode type name

   804         self.CTNType = "Beremiz"

   805         self.Children = {}

   806         # After __init__ root confnode is not valid

   807         self.ProjectPath = None

   808         self._setBuildPath(None)

   809         self.DebugThread = None

   810         self.debug_break = False

   811         self.previous_plcstate = None

   812         # copy ConfNodeMethods so that it can be later customized

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

   814         self.LoadSTLibrary()

   815 

   816     def __del__(self):

   817         if self.DebugTimer:

   818             self.DebugTimer.cancel()

   819         self.KillDebugThread()

   820 

   821     def SetAppFrame(self, frame, logger):

   822         self.AppFrame = frame

   823         self.logger = logger

   824         self.StatusTimer = None

   825         

   826         if frame is not None:

   827             # Timer to pull PLC status

   828             ID_STATUSTIMER = wx.NewId()

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

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

   831         

   832             self.RefreshConfNodesBlockLists()

   833 

   834     def ResetAppFrame(self, logger):

   835         if self.AppFrame is not None:

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

   837             self.StatusTimer = None

   838             self.AppFrame = None

   839         

   840         self.logger = logger

   841 

   842     def ConfNodeLibraryFilePath(self):

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

   844 

   845     def CTNTestModified(self):

   846          return self.ChangesToSave or not self.ProjectIsSaved()

   847 

   848     def CTNFullName(self):

   849         return ""

   850 

   851     def GetCTRoot(self):

   852         return self

   853 

   854     def GetIECLibPath(self):

   855         return self.ieclib_path

   856     

   857     def GetIEC2cPath(self):

   858         return self.iec2c_path

   859     

   860     def GetCurrentLocation(self):

   861         return ()

   862 

   863     def GetCurrentName(self):

   864         return ""

   865     

   866     def _GetCurrentName(self):

   867         return ""

   868 

   869     def GetProjectPath(self):

   870         return self.ProjectPath

   871 

   872     def GetProjectName(self):

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

   874     

   875     def GetDefaultTargetName(self):

   876         if wx.Platform == '__WXMSW__':

   877             return "Win32"

   878         else:

   879             return "Linux"

   880 

   881     def GetTarget(self):

   882         target = self.BeremizRoot.getTargetType()

   883         if target.getcontent() is None:

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

   885             target_name = self.GetDefaultTargetName()

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

   887         return target

   888     

   889     def GetParamsAttributes(self, path = None):

   890         params = ConfigTreeNode.GetParamsAttributes(self, path)

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

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

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

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

   895         return params

   896         

   897     def SetParamsAttribute(self, path, value):

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

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

   900         return ConfigTreeNode.SetParamsAttribute(self, path, value)

   901         

   902     # helper func to check project path write permission

   903     def CheckProjectPathPerm(self, dosave=True):

   904         if CheckPathPerm(self.ProjectPath):

   905             return True

   906         dialog = wx.MessageDialog(self.AppFrame, 

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

   908                     _('Error'), 

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

   910         answer = dialog.ShowModal()

   911         dialog.Destroy()

   912         if answer == wx.ID_YES:

   913             if self.SaveProjectAs():

   914                 self.AppFrame.RefreshAll()

   915                 self.AppFrame.RefreshTitle()

   916                 self.AppFrame.RefreshFileMenu()

   917                 return True

   918         return False

   919     

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

   921         """

   922         Create a new project in an empty folder

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

   924         @param PLCParams: properties of the PLCOpen program created

   925         """

   926         # Verify that chosen folder is empty

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

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

   929         

   930         dialog = ProjectDialog(self.AppFrame)

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

   932             values = dialog.GetValues()

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

   934             dialog.Destroy()

   935         else:

   936             dialog.Destroy()

   937             return _("Project not created")

   938         

   939         # Create PLCOpen program

   940         self.CreateNewProject(values)

   941         # Change XSD into class members

   942         self._AddParamsMembers()

   943         self.Children = {}

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

   945         self.ProjectPath = ProjectPath

   946         self._setBuildPath(BuildPath)

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

   948         self.RefreshConfNodesBlockLists()

   949         # this will create files base XML files

   950         self.SaveProject()

   951         return None

   952         

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

   954         """

   955         Load a project contained in a folder

   956         @param ProjectPath: path of the project folder

   957         """

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

   959             ProjectPath = os.path.dirname(ProjectPath)

   960 		# Verify that project contains a PLCOpen program

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

   962         if not os.path.isfile(plc_file):

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

   964         # Load PLCOpen file

   965         result = self.OpenXMLFile(plc_file)

   966         if result:

   967             return result

   968         # Change XSD into class members

   969         self._AddParamsMembers()

   970         self.Children = {}

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

   972         self.ProjectPath = ProjectPath

   973         self._setBuildPath(BuildPath)

   974         # If dir have already be made, and file exist

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

   976             #Load the confnode.xml file into parameters members

   977             result = self.LoadXMLParams()

   978             if result:

   979                 return result

   980             #Load and init all the children

   981             self.LoadChildren()

   982         self.RefreshConfNodesBlockLists()

   983         

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

   985             self.EnableMethod("_Clean", True)

   986 

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

   988             self.ShowMethod("_showIECcode", True)

   989 

   990         return None

   991     

   992     def CloseProject(self):

   993         self.ClearChildren()

   994         self.ResetAppFrame(None)

   995         

   996     def SaveProject(self):

   997         if self.CheckProjectPathPerm(False):

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

   999             result = self.CTNRequestSave()

  1000             if result:

  1001                 self.logger.write_error(result)

  1002     

  1003     def SaveProjectAs(self, dosave=True):

  1004         # Ask user to choose a path with write permissions

  1005         if wx.Platform == '__WXMSW__':

  1006             path = os.getenv("USERPROFILE")

  1007         else:

  1008             path = os.getenv("HOME")

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

  1010         answer = dirdialog.ShowModal()

  1011         dirdialog.Destroy()

  1012         if answer == wx.ID_OK:

  1013             newprojectpath = dirdialog.GetPath()

  1014             if os.path.isdir(newprojectpath):

  1015                 self.ProjectPath = newprojectpath

  1016                 if dosave:

  1017                     self.SaveProject()

  1018                 self._setBuildPath(self.BuildPath)

  1019                 return True

  1020         return False

  1021     

  1022     # Update PLCOpenEditor ConfNode Block types from loaded confnodes

  1023     def RefreshConfNodesBlockLists(self):

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

  1025             self.ClearConfNodeTypes()

  1026             self.AddConfNodeTypesList(self.ConfNodesTypesFactory())

  1027         if self.AppFrame is not None:

  1028             self.AppFrame.RefreshLibraryPanel()

  1029             self.AppFrame.RefreshEditor()

  1030     

  1031     # Update a PLCOpenEditor Pou variable location

  1032     def UpdateProjectVariableLocation(self, old_leading, new_leading):

  1033         self.Project.updateElementAddress(old_leading, new_leading)

  1034         self.BufferProject()

  1035         if self.AppFrame is not None:

  1036             self.AppFrame.RefreshTitle()

  1037             self.AppFrame.RefreshInstancesTree()

  1038             self.AppFrame.RefreshFileMenu()

  1039             self.AppFrame.RefreshEditMenu()

  1040             self.AppFrame.RefreshEditor()

  1041     

  1042     def GetVariableLocationTree(self):

  1043         '''

  1044         This function is meant to be overridden by confnodes.

  1045 

  1046         It should returns an list of dictionaries

  1047         

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

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

  1050         '''

  1051         children = []

  1052         for child in self.IECSortedChildren():

  1053             children.append(child.GetVariableLocationTree())

  1054         return children

  1055     

  1056     def ConfNodePath(self):

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

  1058     

  1059     def CTNPath(self, CTNName=None):

  1060         return self.ProjectPath

  1061     

  1062     def ConfNodeXmlFilePath(self, CTNName=None):

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

  1064 

  1065     def ParentsTypesFactory(self):

  1066         return self.ConfNodeTypesFactory()

  1067 

  1068     def _setBuildPath(self, buildpath):

  1069         if CheckPathPerm(buildpath):

  1070             self.BuildPath = buildpath

  1071         else:

  1072             self.BuildPath = None

  1073         self.BuildPath = buildpath

  1074         self.DefaultBuildPath = None

  1075         if self._builder is not None:

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

  1077 

  1078     def _getBuildPath(self):

  1079         # BuildPath is defined by user

  1080         if self.BuildPath is not None:

  1081             return self.BuildPath

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

  1083         if self.DefaultBuildPath is not None:

  1084             return self.DefaultBuildPath

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

  1086         if CheckPathPerm(self.ProjectPath):

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

  1088         # Create a build path in temp folder

  1089         else:

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

  1091             

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

  1093             os.makedirs(self.DefaultBuildPath)

  1094         return self.DefaultBuildPath

  1095     

  1096     def _getExtraFilesPath(self):

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

  1098 

  1099     def _getIECcodepath(self):

  1100         # define name for IEC code file

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

  1102     

  1103     def _getIECgeneratedcodepath(self):

  1104         # define name for IEC generated code file

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

  1106     

  1107     def _getIECrawcodepath(self):

  1108         # define name for IEC raw code file

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

  1110     

  1111     def GetLocations(self):

  1112         locations = []

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

  1114         if os.path.isfile(filepath):

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

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

  1117             # each line of LOCATED_VARIABLES.h declares a located variable

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

  1119             # This regular expression parses the lines genereated by IEC2C

  1120             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]*)\)")

  1121             for line in lines:

  1122                 # If line match RE, 

  1123                 result = LOCATED_MODEL.match(line)

  1124                 if result:

  1125                     # Get the resulting dict

  1126                     resdict = result.groupdict()

  1127                     # rewrite string for variadic location as a tuple of integers

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

  1129                     # set located size to 'X' if not given 

  1130                     if not resdict['SIZE']:

  1131                         resdict['SIZE'] = 'X'

  1132                     # finally store into located variable list

  1133                     locations.append(resdict)

  1134         return locations

  1135         

  1136     def _Generate_SoftPLC(self):