beremiz: comparison plugger.py

equal deleted inserted replaced

-:cd81a7a6e55c
+:cb9901076a21
 pass
 def BufferProject(self):
 pass
+# helper func to get path to images
+def opjimg(imgname):
+return os.path.join("images",imgname)
 class PlugTemplate:
 """
 This class is the one that define plugins.
 """
 self._AddParamsMembers()
 self.PluggedChilds = {}
 # copy PluginMethods so that it can be later customized
 self.PluginMethods = [dic.copy() for dic in self.PluginMethods]
-def IsGUIPlugin(self):
-return False
 def PluginBaseXmlFilePath(self, PlugName=None):
 return os.path.join(self.PlugPath(PlugName), "baseplugin.xml")
 def PluginXmlFilePath(self, PlugName=None):
 return os.path.join(self.PlugPath(PlugName), "plugin.xml")
 def PlugPath(self,PlugName=None):
 if not PlugName:
 PlugName = self.BaseParams.getName()
-return os.path.join(self.PlugParent.PlugPath(), PlugName + NameTypeSeparator + self.PlugType)
+return os.path.join(self.PlugParent.PlugPath(),
+PlugName + NameTypeSeparator + self.PlugType)
 def PlugTestModified(self):
 return self.ChangesToSave
 def ProjectTestModified(self):
 params.append(self.MandatoryParams[1].getElementInfos(self.MandatoryParams[0]))
 if self.PlugParams:
 params.append(self.PlugParams[1].getElementInfos(self.PlugParams[0]))
 return params
-def SetParamsAttribute(self, path, value, logger):
+def SetParamsAttribute(self, path, value):
 self.ChangesToSave = True
 # Filter IEC_Channel and Name, that have specific behavior
 if path == "BaseParams.IEC_Channel":
-return self.FindNewIEC_Channel(value,logger), True
+return self.FindNewIEC_Channel(value), True
 elif path == "BaseParams.Name":
-res = self.FindNewName(value,logger)
+res = self.FindNewName(value)
 self.PlugRequestSave()
 return res, True
 parts = path.split(".", 1)
 if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:
 def PlugImport(self, src_PlugPath):
 shutil.copytree(src_PlugPath, self.PlugPath)
 return True
-def PlugGenerate_C(self, buildpath, locations, logger):
+def PlugGenerate_C(self, buildpath, locations):
 """
 Generate C code
 @param locations: List of complete variables locations \
 [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)
 "NAME" : name of the variable (generally "__IW0_1_2" style)
 "SIZE" : size "X", "B", "W", "D", "L"
 "LOC" : tuple of interger for IEC location (0,1,2,...)
 }, ...]
 @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
 """
-logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")
+self.logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")
 return [],"",False
-def _Generate_C(self, buildpath, locations, logger):
+def _Generate_C(self, buildpath, locations):
-# Generate plugins [(Cfiles, CFLAGS)], LDFLAGS
+# Generate plugins [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files
-PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = self.PlugGenerate_C(buildpath, locations, logger)
+# extra_files = [(fname,fobject), ...]
+gen_result = self.PlugGenerate_C(buildpath, locations)
+PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]
+extra_files = gen_result[3:]
 # if some files heve been generated put them in the list with their location
 if PlugCFilesAndCFLAGS:
 LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), PlugCFilesAndCFLAGS, DoCalls)]
 else:
 LocationCFilesAndCFLAGS = []
 # recurse through all childs, and stack their results
 for PlugChild in self.IECSortedChilds():
 new_location = PlugChild.GetCurrentLocation()
 # How deep are we in the tree ?
 depth=len(new_location)
-_LocationCFilesAndCFLAGS, _LDFLAGS = \
+_LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \
 PlugChild._Generate_C(
 #keep the same path
 buildpath,
 # filter locations that start with current IEC location
-[loc for loc in locations if loc["LOC"][0:depth] == new_location ],
+[loc for loc in locations if loc["LOC"][0:depth] == new_location ])
-#propagete logger
-logger)
 # stack the result
 LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS
 LDFLAGS += _LDFLAGS
+extra_files += _extra_files
-return LocationCFilesAndCFLAGS,LDFLAGS
+return LocationCFilesAndCFLAGS, LDFLAGS, extra_files
 def BlockTypesFactory(self):
 return []
 def STLibraryFactory(self):
 if wx.VERSION < (2, 8, 0):
 return {"name" : "%d-%s"%(self.BaseParams.getIEC_Channel(),self.BaseParams.getName()), "type" : self.BaseParams.getName(), "values" : childs}
 else:
 return {"name" : self.BaseParams.getName(), "channel" : self.BaseParams.getIEC_Channel(), "enabled" : self.BaseParams.getEnabled(), "parent" : len(self.PlugChildsTypes) > 0, "type" : self.BaseParams.getName(), "values" : childs}
-def FindNewName(self, DesiredName, logger):
+def FindNewName(self, DesiredName):
 """
 Changes Name to DesiredName if available, Name-N if not.
 @param DesiredName: The desired Name (string)
 """
 # Get Current Name
 # Rename plugin dir if exist
 if not dontexist:
 shutil.move(oldname, self.PlugPath())
 # warn user he has two left hands
 if DesiredName != res:
-logger.write_warning("A child names \"%s\" already exist -> \"%s\"\n"%(DesiredName,res))
+self.logger.write_warning("A child names \"%s\" already exist -> \"%s\"\n"%(DesiredName,res))
 return res
-def FindNewIEC_Channel(self, DesiredChannel, logger):
+def FindNewIEC_Channel(self, DesiredChannel):
 """
 Changes IEC Channel number to DesiredChannel if available, nearest available if not.
 @param DesiredChannel: The desired IEC channel (int)
 """
 # Get Current IEC channel
 res = DesiredChannel
 while res in AllChannels: # While channel not free
 if res < CurrentChannel: # Want to go down ?
 res -=  1 # Test for n-1
 if res < 0 :
-if logger :
+self.logger.write_warning("Cannot find lower free IEC channel than %d\n"%CurrentChannel)
-logger.write_warning("Cannot find lower free IEC channel than %d\n"%CurrentChannel)
 return CurrentChannel # Can't go bellow 0, do nothing
 else : # Want to go up ?
 res +=  1 # Test for n-1
 # Finally set IEC Channel
 self.BaseParams.setIEC_Channel(res)
-if logger and DesiredChannel != res:
+if DesiredChannel != res:
-logger.write_warning("A child with IEC channel %d already exist -> %d\n"%(DesiredChannel,res))
+self.logger.write_warning("A child with IEC channel %d already exist -> %d\n"%(DesiredChannel,res))
 return res
 def OnPlugClose(self):
 return True
 # Fetch the plugin
 #PlugInstance = self.GetChildByName(PlugName)
 # Ask to his parent to remove it
 self.PlugParent._doRemoveChild(self)
-def PlugAddChild(self, PlugName, PlugType, logger):
+def PlugAddChild(self, PlugName, PlugType):
 """
 Create the plugins that may be added as child to this node self
 @param PlugType: string desining the plugin class name (get name from PlugChildsTypes)
 @param PlugName: string for the name of the plugin instance
 """
 before PlugClass.__init__, and to do the file related stuff.
 """
 def __init__(_self):
 # self is the parent
 _self.PlugParent = self
+# self is the parent
+_self.logger = self.logger
 # Keep track of the plugin type name
 _self.PlugType = PlugType
 # remind the help string, for more fancy display
 _self.PlugHelp = PlugHelp
 # Call the base plugin template init - change XSD into class members
 PlugTemplate.__init__(_self)
 # check name is unique
-NewPlugName = _self.FindNewName(PlugName, logger)
+NewPlugName = _self.FindNewName(PlugName)
 # If dir have already be made, and file exist
 if os.path.isdir(_self.PlugPath(NewPlugName)): #and os.path.isfile(_self.PluginXmlFilePath(PlugName)):
 #Load the plugin.xml file into parameters members
-_self.LoadXMLParams(logger, NewPlugName)
+_self.LoadXMLParams(NewPlugName)
 # Basic check. Better to fail immediately.
 if (_self.BaseParams.getName() != NewPlugName):
 raise Exception, "Project tree layout do not match plugin.xml %s!=%s "%(NewPlugName, _self.BaseParams.getName())
 # Now, self.PlugPath() should be OK
 # Check that IEC_Channel is not already in use.
-_self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel(),logger)
+_self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())
 # Call the plugin real __init__
 if getattr(PlugClass, "__init__", None):
 PlugClass.__init__(_self)
 #Load and init all the childs
-_self.LoadChilds(logger)
+_self.LoadChilds()
 #just loaded, nothing to saved
 _self.ChangesToSave = False
 else:
 # If plugin do not have corresponding file/dirs - they will be created on Save
 os.mkdir(_self.PlugPath())
 PluggedChildsWithSameClass.append(newPluginOpj)
 return newPluginOpj
-def LoadXMLParams(self, logger, PlugName = None):
+def LoadXMLParams(self, PlugName = None):
 methode_name = os.path.join(self.PlugPath(PlugName), "methods.py")
 if os.path.isfile(methode_name):
 execfile(methode_name)
 # Get the base xml tree
 if self.MandatoryParams:
-#try:
+try:
 basexmlfile = open(self.PluginBaseXmlFilePath(PlugName), 'r')
 basetree = minidom.parse(basexmlfile)
 self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])
 basexmlfile.close()
-#except Exception, e:
+except Exception, exc:
-#    logger.write_error("Couldn't load plugin base parameters %s :\n %s" % (PlugName, str(e)))
+self.logger.write_error("Couldn't load plugin base parameters %s :\n %s" % (PlugName, str(exc)))
+self.logger.write_error(traceback.format_exc())
 # Get the xml tree
 if self.PlugParams:
-#try:
+try:
 xmlfile = open(self.PluginXmlFilePath(PlugName), 'r')
 tree = minidom.parse(xmlfile)
 self.PlugParams[1].loadXMLTree(tree.childNodes[0])
 xmlfile.close()
-#except Exception, e:
+except Exception, exc:
-#    logger.write_error("Couldn't load plugin parameters %s :\n %s" % (PlugName, str(e)))
+self.logger.write_error("Couldn't load plugin parameters %s :\n %s" % (PlugName, str(exc)))
+self.logger.write_error(traceback.format_exc())
-def LoadChilds(self, logger):
+def LoadChilds(self):
 # Iterate over all PlugName@PlugType in plugin directory, and try to open them
 for PlugDir in os.listdir(self.PlugPath()):
 if os.path.isdir(os.path.join(self.PlugPath(), PlugDir)) and \
 PlugDir.count(NameTypeSeparator) == 1:
 pname, ptype = PlugDir.split(NameTypeSeparator)
-#try:
+try:
-self.PlugAddChild(pname, ptype, logger)
+self.PlugAddChild(pname, ptype)
-#except Exception, e:
+except Exception, exc:
-#    logger.write_error("Could not add child \"%s\", type %s :\n%s\n"%(pname, ptype, str(e)))
+self.logger.write_error("Could not add child \"%s\", type %s :\n%s\n"%(pname, ptype, str(exc)))
+self.logger.write_error(traceback.format_exc())
 def EnableMethod(self, method, value):
 for d in self.PluginMethods:
 if d["method"]==method:
 d["enabled"]=value
+return True
+return False
+def ShowMethod(self, method, value):
+for d in self.PluginMethods:
+if d["method"]==method:
+d["shown"]=value
 return True
 return False
 def _GetClassFunction(name):
 def GetRootClass():
 iec2c_path = os.path.join(base_folder, "matiec", "iec2c"+exe_ext)
 ieclib_path = os.path.join(base_folder, "matiec", "lib")
 # import for project creation timestamping
+from threading import Timer
 from time import localtime
 from datetime import datetime
 # import necessary stuff from PLCOpenEditor
 from PLCControler import PLCControler
 from PLCOpenEditor import PLCOpenEditor, ProjectDialog
 from TextViewer import TextViewer
-from plcopen.structures import IEC_KEYWORDS
+from plcopen.structures import IEC_KEYWORDS, TypeHierarchy_list
+# Construct debugger natively supported types
+DebugTypes = [t for t in zip(*TypeHierarchy_list)[0] if not t.startswith("ANY")] + \
+["STEP","TRANSITION","ACTION"]
 import runtime
 import re
+import targets
+import connectors
+from discovery import DiscoveryDialog
 class PluginsRoot(PlugTemplate, PLCControler):
 """
 This class define Root object of the plugin tree.
 It is responsible of :
 <xsd:complexType>
 <xsd:sequence>
 <xsd:element name="TargetType">
 <xsd:complexType>
 <xsd:choice>
-<xsd:element name="Win32">
+"""+targets.targetchoices+"""
-<xsd:complexType>
-<xsd:attribute name="Priority" type="xsd:integer" use="required"/>
-</xsd:complexType>
-</xsd:element>
-<xsd:element name="Linux">
-<xsd:complexType>
-<xsd:attribute name="Nice" type="xsd:integer" use="required"/>
-</xsd:complexType>
-</xsd:element>
-<xsd:element name="Xenomai">
-<xsd:complexType>
-<xsd:attribute name="xeno_config" type="xsd:string" use="optional" default="/usr/xenomai/"/>
-<xsd:attribute name="Priority" type="xsd:integer" use="required"/>
-</xsd:complexType>
-</xsd:element>
-<xsd:element name="RTAI">
-<xsd:complexType>
-<xsd:attribute name="rtai_config" type="xsd:string" use="required"/>
-<xsd:attribute name="Priority" type="xsd:integer" use="required"/>
-</xsd:complexType>
-</xsd:element>
-<xsd:element name="Library">
-<xsd:complexType>
-<xsd:attribute name="Dynamic" type="xsd:boolean" use="optional" default="true"/>
-</xsd:complexType>
-</xsd:element>
-</xsd:choice>
-</xsd:complexType>
-</xsd:element>
-<xsd:element name="Connection">
-<xsd:complexType>
-<xsd:choice>
-<xsd:element name="Local"/>
-<xsd:element name="TCP_IP">
-<xsd:complexType>
-<xsd:attribute name="Host" type="xsd:string" use="required"/>
-</xsd:complexType>
-</xsd:element>
 </xsd:choice>
 </xsd:complexType>
 </xsd:element>
 </xsd:sequence>
-<xsd:attribute name="Compiler" type="xsd:string" use="optional" default="gcc"/>
-<xsd:attribute name="CFLAGS" type="xsd:string" use="required"/>
-<xsd:attribute name="Linker" type="xsd:string" use="optional" default="ld"/>
-<xsd:attribute name="LDFLAGS" type="xsd:string" use="required"/>
-<xsd:attribute name="Sync_Align_Ratio" use="optional" default="50">
-<xsd:simpleType>
-<xsd:restriction base="xsd:integer">
-<xsd:minInclusive value="1"/>
-<xsd:maxInclusive value="99"/>
-</xsd:restriction>
-</xsd:simpleType>
-</xsd:attribute>
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>
 """
-def __init__(self, frame):
+def __init__(self, frame, logger):
 PLCControler.__init__(self)
 self.MandatoryParams = None
 self.AppFrame = frame
+self.logger = logger
-"""
+self._builder = None
-This method are not called here... but in NewProject and OpenProject
+self._connector = None
-self._AddParamsMembers()
-self.PluggedChilds = {}
+# Setup debug information
-"""
+self.IECdebug_callables = {}
+# Timer to prevent rapid-fire when registering many variables
+self.DebugTimer=Timer(0.5,self.RegisterDebugVarToConnector)
+self.ResetIECProgramsAndVariables()
+#This method are not called here... but in NewProject and OpenProject
+#self._AddParamsMembers()
+#self.PluggedChilds = {}
 # In both new or load scenario, no need to save
 self.ChangesToSave = False
 # root have no parent
 self.PlugParent = None
 # Keep track of the plugin type name
 self.RefreshPluginsBlockLists()
 # this will create files base XML files
 self.SaveProject()
 return None
-def LoadProject(self, ProjectPath, logger):
+def LoadProject(self, ProjectPath):
 """
 Load a project contained in a folder
 @param ProjectPath: path of the project folder
 """
 if os.path.basename(ProjectPath) == "":
 ProjectPath = os.path.dirname(ProjectPath)
-# Verify that project contains a PLCOpen program
+		# Verify that project contains a PLCOpen program
 plc_file = os.path.join(ProjectPath, "plc.xml")
 if not os.path.isfile(plc_file):
 return "Folder choosen doesn't contain a program. It's not a valid project!"
 # Load PLCOpen file
 result = self.OpenXMLFile(plc_file)
 # Keep track of the root plugin (i.e. project path)
 self.ProjectPath = ProjectPath
 # If dir have already be made, and file exist
 if os.path.isdir(self.PlugPath()) and os.path.isfile(self.PluginXmlFilePath()):
 #Load the plugin.xml file into parameters members
-result = self.LoadXMLParams(logger)
+result = self.LoadXMLParams()
 if result:
 return result
 #Load and init all the childs
-self.LoadChilds(logger)
+self.LoadChilds()
 self.RefreshPluginsBlockLists()
+if os.path.exists(self._getBuildPath()):
+self.EnableMethod("_Clean", True)
+if os.path.isfile(self._getIECrawcodepath()):
+self.ShowMethod("_showIECcode", True)
 return None
 def SaveProject(self):
 if not self.SaveXMLFile():
 self.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))
 return self.ProjectPath
 def PluginXmlFilePath(self, PlugName=None):
 return os.path.join(self.PlugPath(PlugName), "beremiz.xml")
-def PlugGenerate_C(self, buildpath, locations, logger):
-"""
-Generate C code
-@param locations: List of complete variables locations \
-[(IEC_loc, IEC_Direction, IEC_Type, Name)]\
-ex: [((0,0,4,5),'I','STRING','__IX_0_0_4_5'),...]
-@return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
-"""
-return [(C_file_name, self.CFLAGS) for C_file_name in self.PLCGeneratedCFiles ] , "", False
 def _getBuildPath(self):
 return os.path.join(self.ProjectPath, "build")
+def _getExtraFilesPath(self):
+return os.path.join(self._getBuildPath(), "extra_files")
 def _getIECcodepath(self):
 # define name for IEC code file
 return os.path.join(self._getBuildPath(), "plc.st")
 def _getIECgeneratedcodepath(self):
 # define name for IEC generated code file
 return os.path.join(self._getBuildPath(), "generated_plc.st")
 def _getIECrawcodepath(self):
 # define name for IEC raw code file
-return os.path.join(self._getBuildPath(), "raw_plc.st")
+return os.path.join(self.PlugPath(), "raw_plc.st")
 def GetLocations(self):
 locations = []
 filepath = os.path.join(self._getBuildPath(),"LOCATED_VARIABLES.h")
 if os.path.isfile(filepath):
 resdict['SIZE'] = 'X'
 # finally store into located variable list
 locations.append(resdict)
 return locations
-def _Generate_SoftPLC(self, logger):
+def _Generate_SoftPLC(self):
 """
 Generate SoftPLC ST/IL/SFC code out of PLCOpenEditor controller, and compile it with IEC2C
 @param buildpath: path where files should be created
-@param logger: the log pseudo file
 """
 # Update PLCOpenEditor Plugin Block types before generate ST code
 self.RefreshPluginsBlockLists()
-logger.write("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n")
+self.logger.write("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n")
 buildpath = self._getBuildPath()
 # ask PLCOpenEditor controller to write ST/IL/SFC code file
 result = self.GenerateProgram(self._getIECgeneratedcodepath())
 if result is not None:
 # Failed !
-logger.write_error("Error in ST/IL/SFC code generator :\n%s\n"%result)
+self.logger.write_error("Error in ST/IL/SFC code generator :\n%s\n"%result)
 return False
 plc_file = open(self._getIECcodepath(), "w")
 if os.path.isfile(self._getIECrawcodepath()):
 plc_file.write(open(self._getIECrawcodepath(), "r").read())
 plc_file.write("\n")
 plc_file.write(open(self._getIECgeneratedcodepath(), "r").read())
 plc_file.close()
-logger.write("Compiling IEC Program in to C code...\n")
+self.logger.write("Compiling IEC Program in to C code...\n")
 # Now compile IEC code into many C files
 # files are listed to stdout, and errors to stderr.
 status, result, err_result = ProcessLogger(
-logger,
+self.logger,
 "\"%s\" -f \"%s\" -I \"%s\" \"%s\""%(
 iec2c_path,
 self._getIECcodepath(),
 ieclib_path, buildpath),
 no_stdout=True).spin()
 if status:
 # Failed !
-logger.write_error("Error : IEC to C compiler returned %d\n"%status)
+self.logger.write_error("Error : IEC to C compiler returned %d\n"%status)
 return False
 # Now extract C files of stdout
 C_files = [ fname for fname in result.splitlines() if fname[-2:]==".c" or fname[-2:]==".C" ]
 # remove those that are not to be compiled because included by others
 C_files.remove("POUS.c")
 if not C_files:
-logger.write_error("Error : At least one configuration and one ressource must be declared in PLC !\n")
+self.logger.write_error("Error : At least one configuration and one ressource must be declared in PLC !\n")
 return False
 # transform those base names to full names with path
 C_files = map(lambda filename:os.path.join(buildpath, filename), C_files)
-logger.write("Extracting Located Variables...\n")
+self.logger.write("Extracting Located Variables...\n")
 # Keep track of generated located variables for later use by self._Generate_C
 self.PLCGeneratedLocatedVars = self.GetLocations()
 # Keep track of generated C files for later use by self.PlugGenerate_C
 self.PLCGeneratedCFiles = C_files
 # compute CFLAGS for plc
-self.CFLAGS = "\"-I"+ieclib_path+"\""
+self.plcCFLAGS = "\"-I"+ieclib_path+"\""
 return True
-def _build(self, logger):
+def GetBuilder(self):
+"""
+Return a Builder (compile C code into machine code)
+"""
+# Get target, module and class name
+targetname = self.BeremizRoot.getTargetType().getcontent()["name"]
+modulename = "targets." + targetname
+classname = targetname + "_target"
+# Get module reference
+try :
+targetmodule = getattr(__import__(modulename), targetname)
+except Exception, msg:
+self.logger.write_error("Can't find module for target %s!\n"%targetname)
+self.logger.write_error(str(msg))
+return None
+# Get target class
+targetclass = getattr(targetmodule, classname)
+# if target already
+if self._builder is None or not isinstance(self._builder,targetclass):
+# Get classname instance
+self._builder = targetclass(self)
+return self._builder
+def GetLastBuildMD5(self):
+builder=self.GetBuilder()
+if builder is not None:
+return builder.GetBinaryCodeMD5()
+else:
+return None
+#######################################################################
+#
+#                C CODE GENERATION METHODS
+#
+#######################################################################
+def PlugGenerate_C(self, buildpath, locations):
+"""
+Return C code generated by iec2c compiler
+when _generate_softPLC have been called
+@param locations: ignored
+@return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
+"""
+return [(C_file_name, self.plcCFLAGS) for C_file_name in self.PLCGeneratedCFiles ] , "-lrt", False
+def ResetIECProgramsAndVariables(self):
+"""
+Reset variable and program list that are parsed from
+CSV file generated by IEC2C compiler.
+"""
+self._ProgramList = None
+self._VariablesList = None
+self._IECPathToIdx = None
+self._IdxToIECPath = None
+def GetIECProgramsAndVariables(self):
+"""
+Parse CSV-like file  VARIABLES.csv resulting from IEC2C compiler.
+Each section is marked with a line staring with '//'
+list of all variables used in various POUs
+"""
+if self._ProgramList is None or self._VariablesList is None:
+try:
+csvfile = os.path.join(self._getBuildPath(),"VARIABLES.csv")
+# describes CSV columns
+ProgramsListAttributeName = ["num", "C_path", "type"]
+VariablesListAttributeName = ["num", "vartype", "IEC_path", "C_path", "type"]
+self._ProgramList = []
+self._VariablesList = []
+self._IECPathToIdx = {}
+self._IdxToIECPath = {}
+# Separate sections
+ListGroup = []
+for line in open(csvfile,'r').xreadlines():
+strippedline = line.strip()
+if strippedline.startswith("//"):
+# Start new section
+ListGroup.append([])
+elif len(strippedline) > 0 and len(ListGroup) > 0:
+# append to this section
+ListGroup[-1].append(strippedline)
+# first section contains programs
+for line in ListGroup[0]:
+# Split and Maps each field to dictionnary entries
+attrs = dict(zip(ProgramsListAttributeName,line.strip().split(';')))
+# Truncate "C_path" to remove conf an ressources names
+attrs["C_path"] = '__'.join(attrs["C_path"].split(".",2)[1:])
+# Push this dictionnary into result.
+self._ProgramList.append(attrs)
+# second section contains all variables
+for line in ListGroup[1]:
+# Split and Maps each field to dictionnary entries
+attrs = dict(zip(VariablesListAttributeName,line.strip().split(';')))
+# Truncate "C_path" to remove conf an ressources names
+attrs["C_path"] = '__'.join(attrs["C_path"].split(".",2)[1:])
+# Push this dictionnary into result.
+self._VariablesList.append(attrs)
+# Fill in IEC<->C translation dicts
+IEC_path=attrs["IEC_path"]
+Idx=int(attrs["num"])
+self._IECPathToIdx[IEC_path]=Idx
+self._IdxToIECPath[Idx]=IEC_path
+except Exception,e:
+self.logger.write_error("Cannot open/parse VARIABLES.csv!\n")
+self.logger.write_error(traceback.format_exc())
+self.ResetIECProgramsAndVariables()
+return False
+return True
+def Generate_plc_debugger(self):
+"""
+Generate trace/debug code out of PLC variable list
+"""
+self.GetIECProgramsAndVariables()
+# prepare debug code
+debug_code = runtime.code("plc_debug") % {
+"programs_declarations":
+"\n".join(["extern %(type)s %(C_path)s;"%p for p in self._ProgramList]),
+"extern_variables_declarations":"\n".join([
+{"PT":"extern %(type)s *%(C_path)s;",
+"VAR":"extern %(type)s %(C_path)s;"}[v["vartype"]]%v
+for v in self._VariablesList if v["C_path"].find('.')<0]),
+"subscription_table_count":
+len(self._VariablesList),
+"variables_pointer_type_table_count":
+len(self._VariablesList),
+"variables_pointer_type_table_initializer":"\n".join([
+{"PT":"    variable_table[%(num)s].ptrvalue = (void*)(%(C_path)s);\n",
+"VAR":"    variable_table[%(num)s].ptrvalue = (void*)(&%(C_path)s);\n"}[v["vartype"]]%v +
+"    variable_table[%(num)s].type = %(type)s_ENUM;\n"%v
+for v in self._VariablesList if v["type"] in DebugTypes ])}
+return debug_code
+def RegisterDebugVarToConnector(self):
+Idxs = []
+if self._connector is not None:
+for IECPath,WeakCallableDict in self.IECdebug_callables:
+if len(WeakCallableDict) == 0:
+# Callable Dict is empty.
+# This variable is not needed anymore!
+self.IECdebug_callables.pop(IECPath)
+else:
+# Convert
+Idx = self._IECPathToIdx.get(IECPath,None)
+if Idx is not None:
+Idxs.append(Idx)
+else:
+self.logger.write_warning("Debug : Unknown variable %s\n"%IECPath)
+self._connector.TraceVariables(Idxs)
+def SubscribeDebugIECVariable(self, IECPath, callable, *args, **kwargs):
+"""
+Dispatching use a dictionnary linking IEC variable paths
+to a WeakKeyDictionary linking
+weakly referenced callables to optionnal args
+"""
+# If no entry exist, create a new one with a fresh WeakKeyDictionary
+self.IECdebug_callables.setdefault(
+IECPath,
+WeakKeyDictionary())[callable]=(args, kwargs)
+# Rearm anti-rapid-fire timer
+self.DebugTimer.cancel()
+self.DebugTimer.start()
+def Generate_plc_common_main(self):
+"""
+Use plugins layout given in LocationCFilesAndCFLAGS to
+generate glue code that dispatch calls to all plugins
+"""
+# filter location that are related to code that will be called
+# in retreive, publish, init, cleanup
+locstrs = map(lambda x:"_".join(map(str,x)),
+[loc for loc,Cfiles,DoCalls in self.LocationCFilesAndCFLAGS if loc and DoCalls])
+# Generate main, based on template
+plc_main_code = runtime.code("plc_common_main") % {
+"calls_prototypes":"\n".join([(
+"int __init_%(s)s(int argc,char **argv);\n"+
+"void __cleanup_%(s)s();\n"+
+"void __retrieve_%(s)s();\n"+
+"void __publish_%(s)s();")%{'s':locstr} for locstr in locstrs]),
+"retrieve_calls":"\n    ".join([
+"__retrieve_%s();"%locstr for locstr in locstrs]),
+"publish_calls":"\n    ".join([ #Call publish in reverse order
+"__publish_%s();"%locstrs[i-1] for i in xrange(len(locstrs), 0, -1)]),
+"init_calls":"\n    ".join([
+"init_level=%d; "%i+
+"if(res = __init_%s(argc,argv)){"%locstr +
+#"printf(\"%s\"); "%locstr + #for debug
+"return res;}" for i,locstr in enumerate(locstrs)]),
+"cleanup_calls":"\n    ".join([
+"if(init_level >= %d) "%i+
+"__cleanup_%s();"%locstrs[i-1] for i in xrange(len(locstrs), 0, -1)])
+}
+target_name = self.BeremizRoot.getTargetType().getcontent()["name"]
+plc_main_code += runtime.code("plc_%s_main"%target_name)
+return plc_main_code
+def _build(self):
 """
 Method called by user to (re)build SoftPLC and plugin tree
 """
 if self.PLCEditor is not None:
 self.PLCEditor.ClearErrors()
 buildpath = self._getBuildPath()
 # Eventually create build dir
 if not os.path.exists(buildpath):
 os.mkdir(buildpath)
+# There is something to clean
-logger.flush()
-logger.write("Start build in %s\n" % buildpath)
 self.EnableMethod("_Clean", True)
-self.EnableMethod("_showIECcode", True)
+self.logger.flush()
-# Generate SoftPLC code
+self.logger.write("Start build in %s\n" % buildpath)
-if not self._Generate_SoftPLC(logger):
-logger.write_error("SoftPLC code generation failed !\n")
+# Generate SoftPLC IEC code
+IECGenRes = self._Generate_SoftPLC()
+self.ShowMethod("_showIECcode", True)
+# If IEC code gen fail, bail out.
+if not IECGenRes:
+self.logger.write_error("IEC-61131-3 code generation failed !\n")
 return False
+# Reset variable and program list that are parsed from
-#logger.write("SoftPLC code generation successfull\n")
+# CSV file generated by IEC2C compiler.
+self.ResetIECProgramsAndVariables()
-logger.write("Generating plugins code ...\n")
 # Generate C code and compilation params from plugin hierarchy
+self.logger.write("Generating plugins C code\n")
 try:
-LocationCFilesAndCFLAGS,LDFLAGS = self._Generate_C(
+self.LocationCFilesAndCFLAGS, self.LDFLAGS, ExtraFiles = self._Generate_C(
 buildpath,
-self.PLCGeneratedLocatedVars,
+self.PLCGeneratedLocatedVars)
-logger)
 except Exception, exc:
-logger.write_error("Plugins code generation Failed !\n")
+self.logger.write_error("Plugins code generation failed !\n")
-logger.write_error(traceback.format_exc())
+self.logger.write_error(traceback.format_exc())
 return False
+# Get temprary directory path
-#debug
+extrafilespath = self._getExtraFilesPath()
-#import pprint
+# Remove old directory
-#pp = pprint.PrettyPrinter(indent=4)
+if os.path.exists(extrafilespath):
-#logger.write("LocationCFilesAndCFLAGS :\n"+pp.pformat(LocationCFilesAndCFLAGS)+"\n")
+shutil.rmtree(extrafilespath)
-#logger.write("LDFLAGS :\n"+pp.pformat(LDFLAGS)+"\n")
+# Recreate directory
+os.mkdir(extrafilespath)
-# Generate main
+# Then write the files
-locstrs = map(lambda x:"_".join(map(str,x)), [loc for loc,Cfiles,DoCalls in LocationCFilesAndCFLAGS if loc and DoCalls])
+for fname,fobject in ExtraFiles:
-plc_main = runtime.code("plc_common_main") % {
+print fname,fobject
-"calls_prototypes":"\n".join(
+fpath = os.path.join(extrafilespath,fname)
-["int __init_%(s)s(int argc,char **argv);\nvoid __cleanup_%(s)s();\nvoid __retrieve_%(s)s();\nvoid __publish_%(s)s();"%
+open(fpath, "wb").write(fobject.read())
-{'s':locstr} for locstr in locstrs]),
+# Now we can forget ExtraFiles (will close files object)
-"retrieve_calls":"\n    ".join(["__retrieve_%(s)s();"%{'s':locstr} for locstr in locstrs]),
+del ExtraFiles
-"publish_calls":"\n    ".join(["__publish_%(s)s();"%{'s':locstr} for locstr in locstrs]),
-"init_calls":"\n    ".join(["init_level++; if(res = __init_%(s)s(argc,argv)) return res;"%{'s':locstr} for locstr in locstrs]),
+# Template based part of C code generation
-"cleanup_calls":"\n    ".join(["if(init_level-- > 0) __cleanup_%(s)s();"%{'s':locstr} for locstr in locstrs]),
+# files are stacked at the beginning, as files of plugin tree root
-"sync_align_ratio":self.BeremizRoot.getSync_Align_Ratio()}
+for generator, filename, name in [
-target_name = self.BeremizRoot.TargetType.content["name"]
+# debugger code
-plc_main += runtime.code("plc_%s_main"%target_name)
+(self.Generate_plc_debugger, "plc_debugger.c", "Debugger"),
+# init/cleanup/retrieve/publish, run and align code
-main_path = os.path.join(buildpath, "main.c" )
+(self.Generate_plc_common_main,"plc_common_main.c","Common runtime")]:
-f = open(main_path,'w')
+try:
-f.write(plc_main)
+# Do generate
-f.close()
+code = generator()
-# First element is necessarely root
+code_path = os.path.join(buildpath,filename)
-LocationCFilesAndCFLAGS[0][1].insert(0,(main_path, self.CFLAGS))
+open(code_path, "w").write(code)
+# Insert this file as first file to be compiled at root plugin
-# Compile the resulting code into object files.
+self.LocationCFilesAndCFLAGS[0][1].insert(0,(code_path, self.plcCFLAGS))
-compiler = self.BeremizRoot.getCompiler()
+except Exception, exc:
-_CFLAGS = self.BeremizRoot.getCFLAGS()
+self.logger.write_error(name+" generation failed !\n")
-linker = self.BeremizRoot.getLinker()
+self.logger.write_error(traceback.format_exc())
-_LDFLAGS = self.BeremizRoot.getLDFLAGS()
+return False
-obns = []
-objs = []
+self.logger.write("C code generated successfully.\n")
-for Location, CFilesAndCFLAGS, DoCalls in LocationCFilesAndCFLAGS:
-if Location:
+# Get current or fresh builder
-logger.write("Plugin : " + self.GetChildByIECLocation(Location).GetCurrentName() + " " + str(Location)+"\n")
+builder = self.GetBuilder()
-else:
+if builder is None:
-logger.write("PLC :\n")
+self.logger.write_error("Fatal : cannot get builder.\n")
-for CFile, CFLAGS in CFilesAndCFLAGS:
-bn = os.path.basename(CFile)
-obn = os.path.splitext(bn)[0]+".o"
-obns.append(obn)
-logger.write("   [CC]  "+bn+" -> "+obn+"\n")
-objectfilename = os.path.splitext(CFile)[0]+".o"
-status, result, err_result = ProcessLogger(
-logger,
-"\"%s\" -c \"%s\" -o \"%s\" %s %s"%
-(compiler, CFile, objectfilename, _CFLAGS, CFLAGS)
-).spin()
-if status != 0:
-logger.write_error("Build failed\n")
-return False
-objs.append(objectfilename)
-# Link all the object files into one executable
-logger.write("Linking :\n")
-exe = self.GetProjectName()
-if target_name == "Win32":
-exe += ".exe"
-exe_path = os.path.join(buildpath, exe)
-logger.write("   [CC]  " + ' '.join(obns)+" -> " + exe + "\n")
-status, result, err_result = ProcessLogger(
-logger,
-"\"%s\" \"%s\" -o \"%s\" %s"%
-(linker,
-'" "'.join(objs),
-exe_path,
-' '.join(LDFLAGS+[_LDFLAGS]))
-).spin()
-if status != 0:
-logger.write_error("Build failed\n")
-self.EnableMethod("_Run", False)
 return False
-self.EnableMethod("_Run", True)
+# Build
+try:
+if not builder.build() :
+self.logger.write_error("C Build failed.\n")
+return False
+except Exception, exc:
+self.logger.write_error("C Build crashed !\n")
+self.logger.write_error(traceback.format_exc())
+return False
+# Update GUI status about need for transfer
+self.CompareLocalAndRemotePLC()
 return True
 def ShowError(self, logger, from_location, to_location):
 chunk_infos = self.GetChunkInfos(from_location, to_location)
 self._EditPLC(logger)
 for infos, (start_row, start_col) in chunk_infos:
 start = (from_location[0] - start_row, from_location[1] - start_col)
 end = (to_location[0] - start_row, to_location[1] - start_col)
 self.PLCEditor.ShowError(infos, start, end)
-def _showIECcode(self, logger):
+def _showIECcode(self):
 plc_file = self._getIECcodepath()
 new_dialog = wx.Frame(self.AppFrame)
 ST_viewer = TextViewer(new_dialog, "", None, None)
 #ST_viewer.Enable(False)
 ST_viewer.SetKeywords(IEC_KEYWORDS)
 text = '(* No IEC code have been generated at that time ! *)'
 ST_viewer.SetText(text = text)
 new_dialog.Show()
-def _editIECrawcode(self, logger):
+def _editIECrawcode(self):
 new_dialog = wx.Frame(self.AppFrame)
-buildpath = self._getBuildPath()
-# Eventually create build dir
-if not os.path.exists(buildpath):
-os.mkdir(buildpath)
 controler = MiniTextControler(self._getIECrawcodepath())
 ST_viewer = TextViewer(new_dialog, "", None, controler)
 #ST_viewer.Enable(False)
 ST_viewer.SetKeywords(IEC_KEYWORDS)
 ST_viewer.RefreshView()
 new_dialog.Show()
-def _EditPLC(self, logger):
+def _EditPLC(self):
 if self.PLCEditor is None:
 self.RefreshPluginsBlockLists()
 def _onclose():
 self.PLCEditor = None
 def _onsave():
 self.PLCEditor.RefreshToolBar()
 self.PLCEditor._onclose = _onclose
 self.PLCEditor._onsave = _onsave
 self.PLCEditor.Show()
-def _Clean(self, logger):
+def _Clean(self):
 if os.path.isdir(os.path.join(self._getBuildPath())):
-logger.write("Cleaning the build directory\n")
+self.logger.write("Cleaning the build directory\n")
 shutil.rmtree(os.path.join(self._getBuildPath()))
 else:
-logger.write_error("Build directory already clean\n")
+self.logger.write_error("Build directory already clean\n")
-self.EnableMethod("_showIECcode", False)
+self.ShowMethod("_showIECcode", False)
 self.EnableMethod("_Clean", False)
-self.EnableMethod("_Run", False)
+self.CompareLocalAndRemotePLC()
-def _Run(self, logger):
+############# Real PLC object access #############
-command_start_plc = os.path.join(self._getBuildPath(),self.GetProjectName() + exe_ext)
+def UpdateMethodsFromPLCStatus(self):
-if os.path.isfile(command_start_plc):
+# Get PLC state : Running or Stopped
-has_gui_plugin = False
+# TODO : use explicit status instead of boolean
-for PlugChild in self.IterChilds():
+if self._connector is not None:
-has_gui_plugin |= PlugChild.IsGUIPlugin()
+status = self._connector.GetPLCstatus()
-logger.write("Starting PLC\n")
+self.logger.write("PLC is %s\n"%status)
-def this_plc_finish_callback(*args):
-if self.runningPLC is not None:
-self.runningPLC = None
-self.reset_finished()
-self.runningPLC = ProcessLogger(
-logger,
-command_start_plc,
-finish_callback = this_plc_finish_callback,
-no_gui=wx.Platform != '__WXMSW__' or not has_gui_plugin)
-self.EnableMethod("_Clean", False)
-self.EnableMethod("_Run", False)
-self.EnableMethod("_Stop", True)
-self.EnableMethod("_build", False)
 else:
-logger.write_error("%s doesn't exist\n" %command_start_plc)
+status = "Disconnected"
+for args in {
-def reset_finished(self):
+"Started":[("_Run", False),
-self.EnableMethod("_Clean", True)
+("_Debug", False),
-self.EnableMethod("_Run", True)
+("_Stop", True)],
-self.EnableMethod("_Stop", False)
+"Stopped":[("_Run", True),
-self.EnableMethod("_build", True)
+("_Debug", True),
+("_Stop", False)],
-def _Stop(self, logger):
+"Empty":  [("_Run", False),
-if self.runningPLC is not None:
+("_Debug", False),
-logger.write("Stopping PLC\n")
+("_Stop", False)],
-was_runningPLC = self.runningPLC
+"Dirty":  [("_Run", True),
-self.runningPLC = None
+("_Debug", True),
-was_runningPLC.kill()
+("_Stop", False)],
-self.reset_finished()
+"Disconnected":  [("_Run", False),
+("_Debug", False),
+("_Stop", False)],
+}.get(status,[]):
+self.ShowMethod(*args)
+def _Run(self):
+"""
+Start PLC
+"""
+if self._connector.StartPLC():
+self.logger.write("Starting PLC\n")
+else:
+self.logger.write_error("Couldn't start PLC !\n")
+self.UpdateMethodsFromPLCStatus()
+def _Debug(self):
+"""
+Start PLC (Debug Mode)
+"""
+if self.GetIECProgramsAndVariables() and self._connector.StartPLC():
+self.logger.write("Starting PLC (debug mode)\n")
+# TODO : laucnch PLCOpenEditor in Debug Mode
+self.logger.write_warning("Debug mode for PLCopenEditor not implemented\n")
+self.logger.write_warning("Starting alternative test GUI\n")
+# TODO : laucnch PLCOpenEditor in Debug Mode
+else:
+self.logger.write_error("Couldn't start PLC debug !\n")
+self.UpdateMethodsFromPLCStatus()
+def _Stop(self):
+"""
+Stop PLC
+"""
+if self._connector.StopPLC():
+self.logger.write("Stopping PLC\n")
+else:
+self.logger.write_error("Couldn't stop PLC !\n")
+self.UpdateMethodsFromPLCStatus()
+def _Connect(self):
+# don't accept re-connetion is already connected
+if self._connector is not None:
+self.logger.write_error("Already connected. Please disconnect\n")
+return
+# Get connector uri
+uri = self.\
+BeremizRoot.\
+getTargetType().\
+getcontent()["value"].\
+getConnection().\
+getURI_location().\
+strip()
+# if uri is empty launch discovery dialog
+if uri == "":
+# Launch Service Discovery dialog
+dia = DiscoveryDialog(self.AppFrame)
+dia.ShowModal()
+uri = dia.GetResult()
+# Nothing choosed or cancel button
+if uri is None:
+return
+else:
+self.\
+BeremizRoot.\
+getTargetType().\
+getcontent()["value"].\
+getConnection().\
+setURI_location(uri)
+# Get connector from uri
+try:
+self._connector = connectors.ConnectorFactory(uri, self)
+except Exception, msg:
+self.logger.write_error("Exception while connecting %s!\n"%uri)
+self.logger.write_error(traceback.format_exc())
+# Did connection success ?
+if self._connector is None:
+# Oups.
+self.logger.write_error("Connection failed to %s!\n"%uri)
+else:
+self.ShowMethod("_Connect", False)
+self.ShowMethod("_Disconnect", True)
+self.ShowMethod("_Transfer", True)
+self.CompareLocalAndRemotePLC()
+self.UpdateMethodsFromPLCStatus()
+def CompareLocalAndRemotePLC(self):
+if self._connector is None:
+return
+# We are now connected. Update button status
+MD5 = self.GetLastBuildMD5()
+# Check remote target PLC correspondance to that md5
+if MD5 is not None:
+if not self._connector.MatchMD5(MD5):
+self.logger.write_warning(
+"Latest build do not match with target, please transfer.\n")
+self.EnableMethod("_Transfer", True)
+else:
+self.logger.write(
+"Latest build match target, no transfer needed.\n")
+self.EnableMethod("_Transfer", True)
+#self.EnableMethod("_Transfer", False)
+else:
+self.logger.write_warning(
+"Cannot compare latest build to target. Please build.\n")
+self.EnableMethod("_Transfer", False)
+def _Disconnect(self):
+self._connector = None
+self.ShowMethod("_Transfer", False)
+self.ShowMethod("_Connect", True)
+self.ShowMethod("_Disconnect", False)
+self.UpdateMethodsFromPLCStatus()
+def _Transfer(self):
+# Get the last build PLC's
+MD5 = self.GetLastBuildMD5()
+# Check if md5 file is empty : ask user to build PLC
+if MD5 is None :
+self.logger.write_error("Failed : Must build before transfer.\n")
+return False
+# Compare PLC project with PLC on target
+if self._connector.MatchMD5(MD5):
+self.logger.write(
+"Latest build already match current target. Transfering anyway...\n")
+# Get temprary directory path
+extrafilespath = self._getExtraFilesPath()
+extrafiles = [(name, open(os.path.join(extrafilespath, name),
+'rb').read()) \
+for name in os.listdir(extrafilespath) \
+if not name=="CVS"]
+for filename, unused in extrafiles:
+print filename
+# Send PLC on target
+builder = self.GetBuilder()
+if builder is not None:
+data = builder.GetBinaryCode()
+if data is not None :
+if self._connector.NewPLC(MD5, data, extrafiles):
+self.logger.write("Transfer completed successfully.\n")
+else:
+self.logger.write_error("Transfer failed\n")
+else:
+self.logger.write_error("No PLC to transfer (did build success ?)\n")
+self.UpdateMethodsFromPLCStatus()
 PluginMethods = [
-{"bitmap" : os.path.join("images", "editPLC"),
+{"bitmap" : opjimg("editPLC"),
 "name" : "Edit PLC",
 "tooltip" : "Edit PLC program with PLCOpenEditor",
 "method" : "_EditPLC"},
-{"bitmap" : os.path.join("images", "Build"),
+{"bitmap" : opjimg("Build"),
 "name" : "Build",
 "tooltip" : "Build project into build folder",
 "method" : "_build"},
-{"bitmap" : os.path.join("images", "Clean"),
+{"bitmap" : opjimg("Clean"),
 "name" : "Clean",
+"enabled" : False,
 "tooltip" : "Clean project build folder",
 "method" : "_Clean"},
-{"bitmap" : os.path.join("images", "Run"),
+{"bitmap" : opjimg("Run"),
 "name" : "Run",
-"enabled" : False,
+"shown" : False,
-"tooltip" : "Run PLC from build folder",
+"tooltip" : "Start PLC",
 "method" : "_Run"},
-{"bitmap" : os.path.join("images", "Stop"),
+{"bitmap" : opjimg("Debug"),
+"name" : "Debug",
+"shown" : False,
+"tooltip" : "Start PLC (debug mode)",
+"method" : "_Debug"},
+{"bitmap" : opjimg("Stop"),
 "name" : "Stop",
-"enabled" : False,
+"shown" : False,
 "tooltip" : "Stop Running PLC",
 "method" : "_Stop"},
-{"bitmap" : os.path.join("images", "ShowIECcode"),
+{"bitmap" : opjimg("Connect"),
+"name" : "Connect",
+"tooltip" : "Connect to the target PLC",
+"method" : "_Connect"},
+{"bitmap" : opjimg("Transfer"),
+"name" : "Transfer",
+"shown" : False,
+"tooltip" : "Transfer PLC",
+"method" : "_Transfer"},
+{"bitmap" : opjimg("Disconnect"),
+"name" : "Disconnect",
+"shown" : False,
+"tooltip" : "Disconnect from PLC",
+"method" : "_Disconnect"},
+{"bitmap" : opjimg("ShowIECcode"),
 "name" : "Show code",
-"enabled" : False,
+"shown" : False,
 "tooltip" : "Show IEC code generated by PLCGenerator",
 "method" : "_showIECcode"},
-{"bitmap" : os.path.join("images", "editIECrawcode"),
+{"bitmap" : opjimg("editIECrawcode"),
 "name" : "Append code",
 "tooltip" : "Edit raw IEC code added to code generated by PLCGenerator",
-"method" : "_editIECrawcode"}
+"method" : "_editIECrawcode"},
 ]

changeset 203	cb9901076a21
parent 202	cd81a7a6e55c
child 204	f572ab819769