beremiz: comparison ProjectController.py

equal deleted inserted replaced

-:dd94b9a68c61
+:92932cd370a4
 self.iec2c_buildopts = None
 self.ieclib_path   = self.findLibPath()
 self.ieclib_c_path = self.findLibCPath()
 def findObject(self, paths, test):
-path=None
+path = None
 for p in paths:
 if test(p):
 path = p
 break
 return path
 def findCmd(self):
-cmd="iec2c"+(".exe" if wx.Platform == '__WXMSW__' else "")
+cmd = "iec2c"+(".exe" if wx.Platform == '__WXMSW__' else "")
-paths=[
+paths = [
 os.path.join(base_folder, "matiec")
 ]
 path = self.findObject(paths, lambda p: os.path.isfile(os.path.join(p, cmd)))
 # otherwise use iec2c from PATH
 if path is not None:
-cmd=os.path.join(path, cmd)
+cmd = os.path.join(path, cmd)
 return cmd
 def findLibPath(self):
-paths=[
+paths = [
 os.path.join(base_folder, "matiec", "lib"),
 "/usr/lib/matiec"
 ]
 path = self.findObject(paths, lambda p: os.path.isfile(os.path.join(p, "ieclib.txt")))
 return path
 def findLibCPath(self):
-path=None
+path = None
-paths=[
+paths = [
 os.path.join(self.ieclib_path, "C"),
 self.ieclib_path]
 path = self.findObject(paths, lambda p: os.path.isfile(os.path.join(p, "iec_types.h")))
 return path
 def findSupportedOptions(self):
 buildcmd = "\"%s\" -h" % (self.getCmd())
-options =["-f", "-l", "-p"]
+options = ["-f", "-l", "-p"]
 buildopt = ""
 try:
 # Invoke compiler. Output files are listed to stdout, errors to stderr
 status, result, err_result = ProcessLogger(None, buildcmd,
 </xsd:choice>
 </xsd:complexType>
 </xsd:element>"""+(("""
 <xsd:element name="Libraries" minOccurs="0">
 <xsd:complexType>
-"""+"\n".join(['<xsd:attribute name='+
+"""+"\n".join(['<xsd:attribute name=' +
-'"Enable_'+ libname + '_Library" '+
+'"Enable_' + libname + '_Library" ' +
 'type="xsd:boolean" use="optional" default="true"/>'
 for libname, lib in features.libraries])+"""
 </xsd:complexType>
-</xsd:element>""") if len(features.libraries)>0 else '') + """
+</xsd:element>""") if len(features.libraries) > 0 else '') + """
 </xsd:sequence>
 <xsd:attribute name="URI_location" type="xsd:string" use="optional" default=""/>
 <xsd:attribute name="Disable_Extensions" type="xsd:boolean" use="optional" default="false"/>
 </xsd:complexType>
 </xsd:element>
 # Setup debug information
 self.IECdebug_datas = {}
 self.IECdebug_lock = Lock()
-self.DebugTimer=None
+self.DebugTimer = None
 self.ResetIECProgramsAndVariables()
 # In both new or load scenario, no need to save
 self.ChangesToSave = False
 # root have no parent
 self.DebugTimer.cancel()
 self.KillDebugThread()
 def LoadLibraries(self):
 self.Libraries = []
-TypeStack=[]
+TypeStack = []
 for libname, clsname in features.libraries:
 if self.BeremizRoot.Libraries is None or getattr(self.BeremizRoot.Libraries, "Enable_"+libname+"_Library"):
 Lib = GetClassImporter(clsname)()(self, libname, TypeStack)
 TypeStack.append(Lib.GetTypes())
 self.Libraries.append(Lib)
 def GetLibrariesSTCode(self):
 return "\n".join([ lib.GetSTCode() for lib in self.Libraries ])
 def GetLibrariesCCode(self, buildpath):
-if len(self.Libraries)==0:
+if len(self.Libraries) == 0:
 return [], [], ()
 self.GetIECProgramsAndVariables()
 LibIECCflags = '"-I%s" -Wno-unused-function' % os.path.abspath(self.GetIECLibPath())
-LocatedCCodeAndFlags=[]
+LocatedCCodeAndFlags = []
-Extras=[]
+Extras = []
 for lib in self.Libraries:
-res=lib.Generate_C(buildpath, self._VariablesList, LibIECCflags)
+res = lib.Generate_C(buildpath, self._VariablesList, LibIECCflags)
 LocatedCCodeAndFlags.append(res[:2])
-if len(res)>2:
+if len(res) > 2:
 Extras.extend(res[2:])
 return map(list, zip(*LocatedCCodeAndFlags))+[tuple(Extras)]
 # Update PLCOpenEditor ConfNode Block types from loaded confnodes
 def RefreshConfNodesBlockLists(self):
 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" ]
+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:
 self.logger.write_error(_("Error : At least one configuration and one resource 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)
 # prepend beremiz include to configuration header
-H_files = [ fname for fname in result.splitlines() if fname[-2:]==".h" or fname[-2:]==".H" ]
+H_files = [ fname for fname in result.splitlines() if fname[-2:] == ".h" or fname[-2:] == ".H" ]
 H_files.remove("LOCATED_VARIABLES.h")
 H_files = map(lambda filename: os.path.join(buildpath, filename), H_files)
 for H_file in H_files:
 with file(H_file, 'r') as original: data = original.read()
 with file(H_file, 'w') as modified: modified.write('#include "beremiz.h"\n' + data)
 # Get classname instance
 self._builder = targetclass(self)
 return self._builder
 def ResetBuildMD5(self):
-builder=self.GetBuilder()
+builder = self.GetBuilder()
 if builder is not None:
 builder.ResetBinaryCodeMD5()
 self.EnableMethod("_Transfer", False)
 def GetLastBuildMD5(self):
-builder=self.GetBuilder()
+builder = self.GetBuilder()
 if builder is not None:
 return builder.GetBinaryCodeMD5()
 else:
 return None
 config_FBs[tuple(parts)] = attrs["C_path"]
 if attrs["vartype"] != "FB" and attrs["type"] in DebugTypesSize:
 # Push this dictionnary into result.
 self._DbgVariablesList.append(attrs)
 # Fill in IEC<->C translation dicts
-IEC_path=attrs["IEC_path"]
+IEC_path = attrs["IEC_path"]
-self._IECPathToIdx[IEC_path]=(Idx, attrs["type"])
+self._IECPathToIdx[IEC_path] = (Idx, attrs["type"])
 # Ignores numbers given in CSV file
 # Idx=int(attrs["num"])
 # Count variables only, ignore FBs
-Idx+=1
+Idx += 1
 self._VariablesList.append(attrs)
 # third section contains ticktime
 if len(ListGroup) > 2:
 self._Ticktime = int(ListGroup[2][0])
 variable_decl_array = []
 bofs = 0
 for v in self._DbgVariablesList:
 sz = DebugTypesSize.get(v["type"], 0)
 variable_decl_array += [
-"{&(%(C_path)s), " % v+
+"{&(%(C_path)s), " % v +
 {
 "EXT": "%(type)s_P_ENUM",
 "IN":  "%(type)s_P_ENUM",
 "MEM": "%(type)s_O_ENUM",
 "OUT": "%(type)s_O_ENUM",
 "MEM": "extern __IEC_%(type)s_p %(C_path)s;",
 "OUT": "extern __IEC_%(type)s_p %(C_path)s;",
 "VAR": "extern __IEC_%(type)s_t %(C_path)s;",
 "FB":  "extern       %(type)s   %(C_path)s;"
 }[v["vartype"]] % v
-for v in self._VariablesList if v["C_path"].find('.')<0]),
+for v in self._VariablesList if v["C_path"].find('.') < 0]),
 "variable_decl_array": ",\n".join(variable_decl_array)
 }
 return debug_code
 # Generate main, based on template
 if not self.BeremizRoot.getDisable_Extensions():
 plc_main_code = targets.GetCode("plc_main_head.c") % {
 "calls_prototypes": "\n".join([(
-"int __init_%(s)s(int argc,char **argv);\n"+
+"int __init_%(s)s(int argc,char **argv);\n" +
-"void __cleanup_%(s)s(void);\n"+
+"void __cleanup_%(s)s(void);\n" +
-"void __retrieve_%(s)s(void);\n"+
+"void __retrieve_%(s)s(void);\n" +
 "void __publish_%(s)s(void);") % {'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+1)+
+"init_level=%d; " % (i+1) +
 "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+
+"if(init_level >= %d) " % i +
 "__cleanup_%s();" % locstrs[i-1] for i in xrange(len(locstrs), 0, -1)])
 }
 else:
 plc_main_code = targets.GetCode("plc_main_head.c") % {
 "calls_prototypes": "\n",
 [list() for n in xrange(len(self.TracedIECPath))])
 ticks, self.DebugTicks = self.DebugTicks, []
 return ticks, buffers
 def RegisterDebugVarToConnector(self):
-self.DebugTimer=None
+self.DebugTimer = None
 Idxs = []
 self.TracedIECPath = []
 self.TracedIECTypes = []
 if self._connector is not None:
 self.IECdebug_lock.acquire()
 # If an output location var is forced it's leads to segmentation fault in runtime
 # Links between PLC located variables and real variables are not ready
 if self.IsPLCStarted():
 # Timer to prevent rapid-fire when registering many variables
 # use wx.CallAfter use keep using same thread. TODO : use wx.Timer instead
-self.DebugTimer=Timer(0.5, wx.CallAfter, args = [self.RegisterDebugVarToConnector])
+self.DebugTimer = Timer(0.5, wx.CallAfter, args = [self.RegisterDebugVarToConnector])
 # Rearm anti-rapid-fire timer
 self.DebugTimer.start()
 def GetDebugIECVariableType(self, IECPath):
 Idx, IEC_Type = self._IECPathToIdx.get(IECPath, (None, None))
 buffer_list]                # Forced value
 self.IECdebug_datas[IECPath] = IECdebug_data
 else:
 IECdebug_data[4] |= buffer_list
-IECdebug_data[0][callableobj]=buffer_list
+IECdebug_data[0][callableobj] = buffer_list
 self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 },
 ]
 def EnableMethod(self, method, value):
 for d in self.StatusMethods:
-if d["method"]==method:
+if d["method"] == method:
-d["enabled"]=value
+d["enabled"] = value
 return True
 return False
 def ShowMethod(self, method, value):
 for d in self.StatusMethods:
-if d["method"]==method:
+if d["method"] == method:
-d["shown"]=value
+d["shown"] = value
 return True
 return False
 def CallMethod(self, method):
 for d in self.StatusMethods:
-if d["method"]==method and d.get("enabled", True) and d.get("shown", True):
+if d["method"] == method and d.get("enabled", True) and d.get("shown", True):
 getattr(self, method)()

changeset 1742	92932cd370a4
parent 1741	dd94b9a68c61
child 1744	69dfdb26f600