beremiz: comparison ProjectController.py

equal deleted inserted replaced

-:a3ac46366b86
+:70143c20d2c0
 from runtime.typemapping import DebugTypesSize, UnpackDebugBuffer
 from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage
 base_folder = paths.AbsParentDir(__file__)
-MATIEC_ERROR_MODEL = re.compile(".*\.st:(\d+)-(\d+)\.\.(\d+)-(\d+): (?:error)|(?:warning) : (.*)$")
+MATIEC_ERROR_MODEL = re.compile(
+".*\.st:(\d+)-(\d+)\.\.(\d+)-(\d+): (?:error)|(?:warning) : (.*)$")
 def ExtractChildrenTypesFromCatalog(catalog):
 children_types = []
 for n, d, _h, c in catalog:
 def GetAddMenuItems():
 return ExtractMenuItemsFromCatalog(features.catalog)
 class Iec2CSettings(object):
 def __init__(self):
 self.iec2c = None
 self.iec2c_buildopts = None
 self.ieclib_path = self.findLibPath()
 self.ieclib_c_path = self.findLibCPath()
 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 = [
 os.path.join(base_folder, "matiec")
 ]
-path = self.findObject(paths, lambda p: os.path.isfile(os.path.join(p, cmd)))
+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)
 def findLibPath(self):
 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")))
+path = self.findObject(
+paths, lambda p: os.path.isfile(os.path.join(p, "ieclib.txt")))
 return path
 def findLibCPath(self):
 path = None
 if self.ieclib_path is not None:
 buildcmd = "\"%s\" -h" % (self.getCmd())
 options = ["-f", "-l", "-p"]
 buildopt = ""
 try:
-# Invoke compiler. Output files are listed to stdout, errors to stderr
+# Invoke compiler.
+# Output files are listed to stdout, errors to stderr
 _status, result, _err_result = ProcessLogger(None, buildcmd,
 no_stdout=True,
 no_stderr=True).spin()
 except Exception:
 return buildopt
 <xsd:complexType>
 <xsd:sequence>
 <xsd:element name="TargetType">
 <xsd:complexType>
 <xsd:choice minOccurs="0">
-"""+targets.GetTargetChoices()+"""
+""" + targets.GetTargetChoices() + """
 </xsd:choice>
 </xsd:complexType>
-</xsd:element>"""+(("""
+</xsd:element>""" + (("""
 <xsd:element name="Libraries" minOccurs="0">
 <xsd:complexType>
-"""+"\n".join(['<xsd:attribute name=' +
+""" + "\n".join(['<xsd:attribute name=' +
 '"Enable_' + libname + '_Library" ' +
-'type="xsd:boolean" use="optional" default="false"/>'
+'type="xsd:boolean" use="optional" default="' +
-for libname, _lib in features.libraries])+"""
+('true' if default else 'false') + '"/>'
+for libname, _lib, default in features.libraries]) + """
 </xsd:complexType>
 </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"/>
 """
 return XSD
 class ProjectController(ConfigTreeNode, PLCControler):
 """
 This class define Root object of the confnode tree.
 It is responsible of :
 - Managing project directory
 - Building project
 - Handling PLCOpenEditor controler and view
 - Loading user confnodes and instanciante them as children
 - ...
 """
-# For root object, available Children Types are modules of the confnode packages.
+# For root object, available Children Types are modules of the confnode
+# packages.
 CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)
 XSD = GetProjectControllerXSD()
 EditorType = ProjectNodeEditor
 iec2c_cfg = None
 self.KillDebugThread()
 def LoadLibraries(self):
 self.Libraries = []
 TypeStack = []
-for libname, clsname in features.libraries:
+for libname, clsname, _default in features.libraries:
-if self.BeremizRoot.Libraries is not None and getattr(self.BeremizRoot.Libraries, "Enable_"+libname+"_Library"):
+if self.BeremizRoot.Libraries is not None and \
+getattr(self.BeremizRoot.Libraries,
+"Enable_" + libname + "_Library"):
 Lib = GetClassImporter(clsname)()(self, libname, TypeStack)
 TypeStack.append(Lib.GetTypes())
 self.Libraries.append(Lib)
 def SetAppFrame(self, frame, logger):
 if target.getcontent() is None:
 temp_root = self.Parser.CreateRoot()
 target = self.Parser.CreateElement("TargetType", "BeremizRoot")
 temp_root.setTargetType(target)
 target_name = self.GetDefaultTargetName()
-target.setcontent(self.Parser.CreateElement(target_name, "TargetType"))
+target.setcontent(
+self.Parser.CreateElement(target_name, "TargetType"))
 return target
 def GetParamsAttributes(self, path=None):
 params = ConfigTreeNode.GetParamsAttributes(self, path)
 if params[0]["name"] == "BeremizRoot":
 for child in params[0]["children"]:
 if child["name"] == "TargetType" and child["value"] == '':
-child.update(self.GetTarget().getElementInfos("TargetType"))
+child.update(
+self.GetTarget().getElementInfos("TargetType"))
 return params
 def SetParamsAttribute(self, path, value):
 if path.startswith("BeremizRoot.TargetType.") and self.BeremizRoot.getTargetType().getcontent() is None:
 self.BeremizRoot.setTargetType(self.GetTarget())
 return False
 def _getProjectFilesPath(self, project_path=None):
 if project_path is not None:
 return os.path.join(project_path, "project_files")
-projectfiles_path = os.path.join(self.GetProjectPath(), "project_files")
+projectfiles_path = os.path.join(
+self.GetProjectPath(), "project_files")
 if not os.path.exists(projectfiles_path):
 os.mkdir(projectfiles_path)
 return projectfiles_path
 def AddProjectDefaultConfiguration(self, config_name="config", res_name="resource1"):
 self.ProjectAddConfiguration(config_name)
 self.ProjectAddConfigurationResource(config_name, res_name)
 def SetProjectDefaultConfiguration(self):
 # Sets default task and instance for new project
-config = self.Project.getconfiguration(self.GetProjectMainConfigurationName())
+config = self.Project.getconfiguration(
+self.GetProjectMainConfigurationName())
 resource = config.getresource()[0].getname()
 config = config.getname()
 resource_tagname = ComputeConfigurationResourceName(config, resource)
 def_task = [
 {'Priority': '0', 'Single': '', 'Interval': 'T#20ms', 'Name': 'task0', 'Triggering': 'Cyclic'}]
 # Load PLCOpen file
 error = self.OpenXMLFile(plc_file)
 if error is not None:
 if self.Project is not None:
 (fname_err, lnum, src) = (("PLC",) + error)
-self.logger.write_warning(XSDSchemaErrorMessage.format(a1=fname_err, a2=lnum, a3=src))
+self.logger.write_warning(
+XSDSchemaErrorMessage.format(a1=fname_err, a2=lnum, a3=src))
 else:
 return error, False
 if len(self.GetProjectConfigNames()) == 0:
 self.AddProjectDefaultConfiguration()
 # Change XSD into class members
 self.ResetAppFrame(None)
 def CheckNewProjectPath(self, old_project_path, new_project_path):
 if old_project_path == new_project_path:
 message = (_("Save path is the same as path of a project! \n"))
-dialog = wx.MessageDialog(self.AppFrame, message, _("Error"), wx.OK | wx.ICON_ERROR)
+dialog = wx.MessageDialog(
+self.AppFrame, message, _("Error"), wx.OK | wx.ICON_ERROR)
 dialog.ShowModal()
 return False
 else:
 plc_file = os.path.join(new_project_path, "plc.xml")
 if os.path.isfile(plc_file):
-message = (_("Selected directory already contains another project. Overwrite? \n"))
+message = (
-dialog = wx.MessageDialog(self.AppFrame, message, _("Error"), wx.YES_NO | wx.ICON_ERROR)
+_("Selected directory already contains another project. Overwrite? \n"))
+dialog = wx.MessageDialog(
+self.AppFrame, message, _("Error"), wx.YES_NO | wx.ICON_ERROR)
 answer = dialog.ShowModal()
 return answer == wx.ID_YES
 return True
 def SaveProject(self, from_project_path=None):
 if self.CheckProjectPathPerm(False):
 if from_project_path is not None:
-old_projectfiles_path = self._getProjectFilesPath(from_project_path)
+old_projectfiles_path = self._getProjectFilesPath(
+from_project_path)
 if os.path.isdir(old_projectfiles_path):
 shutil.copytree(old_projectfiles_path,
 self._getProjectFilesPath(self.ProjectPath))
 self.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))
 result = self.CTNRequestSave(from_project_path)
 # Ask user to choose a path with write permissions
 if wx.Platform == '__WXMSW__':
 path = os.getenv("USERPROFILE")
 else:
 path = os.getenv("HOME")
-dirdialog = wx.DirDialog(self.AppFrame, _("Choose a directory to save project"), path, wx.DD_NEW_DIR_BUTTON)
+dirdialog = wx.DirDialog(
+self.AppFrame, _("Choose a directory to save project"), path, wx.DD_NEW_DIR_BUTTON)
 answer = dirdialog.ShowModal()
 dirdialog.Destroy()
 if answer == wx.ID_OK:
 newprojectpath = dirdialog.GetPath()
 if os.path.isdir(newprojectpath):
 def GetLibrariesCCode(self, buildpath):
 if len(self.Libraries) == 0:
 return [], [], ()
 self.GetIECProgramsAndVariables()
-LibIECCflags = '"-I%s" -Wno-unused-function' % os.path.abspath(self.GetIECLibPath())
+LibIECCflags = '"-I%s" -Wno-unused-function' % os.path.abspath(
+self.GetIECLibPath())
 LocatedCCodeAndFlags = []
 Extras = []
 for lib in self.Libraries:
 res = lib.Generate_C(buildpath, self._VariablesList, LibIECCflags)
 LocatedCCodeAndFlags.append(res[:2])
 if len(res) > 2:
 Extras.extend(res[2:])
-return map(list, zip(*LocatedCCodeAndFlags))+[tuple(Extras)]
+return map(list, zip(*LocatedCCodeAndFlags)) + [tuple(Extras)]
 # Update PLCOpenEditor ConfNode Block types from loaded confnodes
 def RefreshConfNodesBlockLists(self):
 if getattr(self, "Children", None) is not None:
 self.ClearConfNodeTypes()
 # Create a build path in project folder if user has permissions
 if CheckPathPerm(self.ProjectPath):
 self.DefaultBuildPath = os.path.join(self.ProjectPath, "build")
 # Create a build path in temp folder
 else:
-self.DefaultBuildPath = os.path.join(tempfile.mkdtemp(), os.path.basename(self.ProjectPath), "build")
+self.DefaultBuildPath = os.path.join(
+tempfile.mkdtemp(), os.path.basename(self.ProjectPath), "build")
 if not os.path.exists(self.DefaultBuildPath):
 os.makedirs(self.DefaultBuildPath)
 return self.DefaultBuildPath
 def GetLocations(self):
 locations = []
 filepath = os.path.join(self._getBuildPath(), "LOCATED_VARIABLES.h")
 if os.path.isfile(filepath):
-# IEC2C compiler generate a list of located variables : LOCATED_VARIABLES.h
+# IEC2C compiler generate a list of located variables :
-location_file = open(os.path.join(self._getBuildPath(), "LOCATED_VARIABLES.h"))
+# LOCATED_VARIABLES.h
+location_file = open(
+os.path.join(self._getBuildPath(), "LOCATED_VARIABLES.h"))
 # each line of LOCATED_VARIABLES.h declares a located variable
 lines = [line.strip() for line in location_file.readlines()]
 # This regular expression parses the lines genereated by IEC2C
-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]*)\)")
+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]*)\)")
 for line in lines:
 # If line match RE,
 result = LOCATED_MODEL.match(line)
 if result:
 # Get the resulting dict
 resdict = result.groupdict()
-# rewrite string for variadic location as a tuple of integers
+# rewrite string for variadic location as a tuple of
+# integers
 resdict['LOC'] = tuple(map(int, resdict['LOC'].split(',')))
 # set located size to 'X' if not given
 if not resdict['SIZE']:
 resdict['SIZE'] = 'X'
 # finally store into located variable list
 """
 # Update PLCOpenEditor ConfNode Block types before generate ST code
 self.RefreshConfNodesBlockLists()
-self.logger.write(_("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n"))
+self.logger.write(
+_("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n"))
 # ask PLCOpenEditor controller to write ST/IL/SFC code file
-_program, errors, warnings = self.GenerateProgram(self._getIECgeneratedcodepath())
+_program, errors, warnings = self.GenerateProgram(
+self._getIECgeneratedcodepath())
 if len(warnings) > 0:
-self.logger.write_warning(_("Warnings in ST/IL/SFC code generator :\n"))
+self.logger.write_warning(
+_("Warnings in ST/IL/SFC code generator :\n"))
 for warning in warnings:
 self.logger.write_warning("%s\n" % warning)
 if len(errors) > 0:
 # Failed !
-self.logger.write_error(_("Error in ST/IL/SFC code generator :\n%s\n") % errors[0])
+self.logger.write_error(
+_("Error in ST/IL/SFC code generator :\n%s\n") % errors[0])
 return False
 plc_file = open(self._getIECcodepath(), "w")
 # Add ST Library from confnodes
 plc_file.write(self.GetLibrariesSTCode())
 if os.path.isfile(self._getIECrawcodepath()):
 iec2c_libpath,
 buildpath,
 self._getIECcodepath())
 try:
-# Invoke compiler. Output files are listed to stdout, errors to stderr
+# Invoke compiler.
+# Output files are listed to stdout, errors to stderr
 status, result, err_result = ProcessLogger(self.logger, buildcmd,
-no_stdout=True, no_stderr=True).spin()
+no_stdout=True,
+no_stderr=True).spin()
 except Exception, e:
 self.logger.write_error(buildcmd + "\n")
 self.logger.write_error(repr(e) + "\n")
 return False
 if line[0] not in '\t \r\n':
 last_section = line
 if first_line <= i <= last_line:
 if last_section is not None:
-self.logger.write_warning("In section: " + last_section)
+self.logger.write_warning(
+"In section: " + last_section)
 last_section = None  # only write section once
 self.logger.write_warning("%04d: %s" % (i, line))
 f.close()
-self.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"]
+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"))
+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)
+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)
+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)
 self.logger.write(_("Extracting Located Variables...\n"))
-# Keep track of generated located variables for later use by self._Generate_C
+# 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.CTNGenerate_C
 self.PLCGeneratedCFiles = C_files
 # compute CFLAGS for plc
 self.plcCFLAGS = '"-I%s" -Wno-unused-function' % self.iec2c_cfg.getLibCPath()
 if builder is not None:
 return builder.GetBinaryCodeMD5()
 else:
 return None
-#######################################################################
+#
 #
 #                C CODE GENERATION METHODS
 #
-#######################################################################
+#
 def CTNGenerate_C(self, buildpath, locations):
 """
 Return C code generated by iec2c compiler
 when _generate_softPLC have been called
 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"]
+VariablesListAttributeName = [
+"num", "vartype", "IEC_path", "C_path", "type"]
 self._ProgramList = []
 self._VariablesList = []
 self._DbgVariablesList = []
 self._IECPathToIdx = {}
 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(';')))
+attrs = dict(
+zip(ProgramsListAttributeName, line.strip().split(';')))
 # Truncate "C_path" to remove conf an resources names
-attrs["C_path"] = '__'.join(attrs["C_path"].split(".", 2)[1:])
+attrs["C_path"] = '__'.join(
+attrs["C_path"].split(".", 2)[1:])
 # Push this dictionnary into result.
 self._ProgramList.append(attrs)
 # second section contains all variables
 config_FBs = {}
 Idx = 0
 for line in ListGroup[1]:
 # Split and Maps each field to dictionnary entries
-attrs = dict(zip(VariablesListAttributeName, line.strip().split(';')))
+attrs = dict(
+zip(VariablesListAttributeName, line.strip().split(';')))
 # Truncate "C_path" to remove conf an resources names
 parts = attrs["C_path"].split(".", 2)
 if len(parts) > 2:
 config_FB = config_FBs.get(tuple(parts[:2]))
 if config_FB:
 # third section contains ticktime
 if len(ListGroup) > 2:
 self._Ticktime = int(ListGroup[2][0])
 except Exception:
-self.logger.write_error(_("Cannot open/parse VARIABLES.csv!\n"))
+self.logger.write_error(
+_("Cannot open/parse VARIABLES.csv!\n"))
 self.logger.write_error(traceback.format_exc())
 self.ResetIECProgramsAndVariables()
 return False
 return True
 "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)]),
+"__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 +
-"__cleanup_%s();" % locstrs[i-1] for i in xrange(len(locstrs), 0, -1)])
+"__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",
 "retrieve_calls":   "\n",
 "publish_calls":    "\n",
 "init_calls":       "\n",
 "cleanup_calls":    "\n"
 }
-plc_main_code += targets.GetTargetCode(self.GetTarget().getcontent().getLocalTag())
+plc_main_code += targets.GetTargetCode(
+self.GetTarget().getcontent().getLocalTag())
 plc_main_code += targets.GetCode("plc_main_tail.c")
 return plc_main_code
 def _Build(self):
 """
 try:
 CTNLocationCFilesAndCFLAGS, CTNLDFLAGS, CTNExtraFiles = self._Generate_C(
 buildpath,
 self.PLCGeneratedLocatedVars)
 except Exception:
-self.logger.write_error(_("Runtime IO extensions C code generation failed !\n"))
+self.logger.write_error(
+_("Runtime IO extensions C code generation failed !\n"))
 self.logger.write_error(traceback.format_exc())
 self.ResetBuildMD5()
 return False
 # Generate C code and compilation params from liraries
 try:
-LibCFilesAndCFLAGS, LibLDFLAGS, LibExtraFiles = self.GetLibrariesCCode(buildpath)
+LibCFilesAndCFLAGS, LibLDFLAGS, LibExtraFiles = self.GetLibrariesCCode(
+buildpath)
 except Exception:
-self.logger.write_error(_("Runtime library extensions C code generation failed !\n"))
+self.logger.write_error(
+_("Runtime library extensions C code generation failed !\n"))
 self.logger.write_error(traceback.format_exc())
 self.ResetBuildMD5()
 return False
-self.LocationCFilesAndCFLAGS = LibCFilesAndCFLAGS + CTNLocationCFilesAndCFLAGS
+self.LocationCFilesAndCFLAGS = LibCFilesAndCFLAGS + \
+CTNLocationCFilesAndCFLAGS
 self.LDFLAGS = CTNLDFLAGS + LibLDFLAGS
 ExtraFiles = CTNExtraFiles + LibExtraFiles
 # Get temporary directory path
 extrafilespath = self._getExtraFilesPath()
 open(fpath, "wb").write(fobject.read())
 # Now we can forget ExtraFiles (will close files object)
 del ExtraFiles
 # Header file for extensions
-open(os.path.join(buildpath, "beremiz.h"), "w").write(targets.GetHeader())
+open(os.path.join(buildpath, "beremiz.h"), "w").write(
+targets.GetHeader())
 # Template based part of C code generation
 # files are stacked at the beginning, as files of confnode tree root
 c_source = [
 #  debugger code
 code = generator()
 if code is None:
 raise Exception
 code_path = os.path.join(buildpath, filename)
 open(code_path, "w").write(code)
-# Insert this file as first file to be compiled at root confnode
+# Insert this file as first file to be compiled at root
-self.LocationCFilesAndCFLAGS[0][1].insert(0, (code_path, self.plcCFLAGS))
+# confnode
+self.LocationCFilesAndCFLAGS[0][1].insert(
+0, (code_path, self.plcCFLAGS))
 except Exception:
-self.logger.write_error(name+_(" generation failed !\n"))
+self.logger.write_error(name + _(" generation failed !\n"))
 self.logger.write_error(traceback.format_exc())
 self.ResetBuildMD5()
 return False
 self.logger.write(_("C code generated successfully.\n"))
 return True
 def ShowError(self, logger, from_location, to_location):
 chunk_infos = self.GetChunkInfos(from_location, to_location)
 for infos, (start_row, start_col) in chunk_infos:
-row = 1 if from_location[0] < start_row else (from_location[0] - start_row)
+row = 1 if from_location[0] < start_row else (
-col = 1 if (start_row != from_location[0]) else (from_location[1] - start_col)
+from_location[0] - start_row)
+col = 1 if (start_row != from_location[0]) else (
+from_location[1] - start_col)
 start = (row, col)
-row = 1 if to_location[0] < start_row else (to_location[0] - start_row)
+row = 1 if to_location[0] < start_row else (
-col = 1 if (start_row != to_location[0]) else (to_location[1] - start_col)
+to_location[0] - start_row)
+col = 1 if (start_row != to_location[0]) else (
+to_location[1] - start_col)
 end = (row, col)
 if self.AppFrame is not None:
 self.AppFrame.ShowError(infos, start, end)
 def _OpenView(self, name=None, onlyopened=False):
 if name == "IEC code":
 if self._IECCodeView is None:
 plc_file = self._getIECcodepath()
-self._IECCodeView = IECCodeViewer(self.AppFrame.TabsOpened, "", self.AppFrame, None, instancepath=name)
+self._IECCodeView = IECCodeViewer(
+self.AppFrame.TabsOpened, "", self.AppFrame, None, instancepath=name)
 self._IECCodeView.SetTextSyntax("ALL")
 self._IECCodeView.SetKeywords(IEC_KEYWORDS)
 try:
 text = file(plc_file).read()
 except Exception:
 elif name == "IEC raw code":
 if self._IECRawCodeView is None:
 controler = MiniTextControler(self._getIECrawcodepath(), self)
-self._IECRawCodeView = IECCodeViewer(self.AppFrame.TabsOpened, "", self.AppFrame, controler, instancepath=name)
+self._IECRawCodeView = IECCodeViewer(
+self.AppFrame.TabsOpened, "", self.AppFrame, controler, instancepath=name)
 self._IECRawCodeView.SetTextSyntax("ALL")
 self._IECRawCodeView.SetKeywords(IEC_KEYWORDS)
 self._IECRawCodeView.RefreshView()
 self._IECRawCodeView.SetIcon(GetBitmap("ST"))
 setattr(self._IECRawCodeView, "_OnClose", self.OnCloseEditor)
 return self._IECRawCodeView
 elif name == "Project Files":
 if self._ProjectFilesView is None:
-self._ProjectFilesView = FileManagementPanel(self.AppFrame.TabsOpened, self, name, self._getProjectFilesPath(), True)
+self._ProjectFilesView = FileManagementPanel(
+self.AppFrame.TabsOpened, self, name, self._getProjectFilesPath(), True)
 extensions = []
 for extension, name, editor in features.file_editors:
 if extension not in extensions:
 extensions.append(extension)
 if editor_name != "":
 name = "::".join([filepath, editor_name])
 editor = editors[editor_name]()
-self._FileEditors[filepath] = editor(self.AppFrame.TabsOpened, self, name, self.AppFrame)
+self._FileEditors[filepath] = editor(
+self.AppFrame.TabsOpened, self, name, self.AppFrame)
 self._FileEditors[filepath].SetIcon(GetBitmap("FILE"))
 if isinstance(self._FileEditors[filepath], DebugViewer):
 self._FileEditors[filepath].SetDataProducer(self)
 if filepath in self._FileEditors:
 def UpdatePLCLog(self, log_count):
 if log_count:
 if self.AppFrame is not None:
 self.AppFrame.LogViewer.SetLogCounters(log_count)
+DefaultMethods = {
+"_Run": False,
+"_Stop": False,
+"_Transfer": False,
+"_Connect": True,
+"_Disconnect": False
+}
+MethodsFromStatus = {
+"Started":      {"_Stop": True,
+"_Transfer": True,
+"_Connect": False,
+"_Disconnect": True},
+"Stopped":      {"_Run": True,
+"_Transfer": True,
+"_Connect": False,
+"_Disconnect": True},
+"Empty":        {"_Transfer": True,
+"_Connect": False,
+"_Disconnect": True},
+"Broken":       {"_Connect": False,
+"_Disconnect": True},
+"Disconnected": {},
+}
 def UpdateMethodsFromPLCStatus(self):
 updated = False
 status = None
 if self._connector is not None:
 self.UpdatePLCLog(log_count)
 if status is None:
 self._SetConnector(None, False)
 status = "Disconnected"
 if self.previous_plcstate != status:
-for args in {
+allmethods = self.DefaultMethods.copy()
-"Started":      [("_Run", False),
+allmethods.update(
-("_Stop", True)],
+self.MethodsFromStatus.get(status, {}))
-"Stopped":      [("_Run", True),
+for method, active in allmethods.items():
-("_Stop", False)],
+self.ShowMethod(method, active)
-"Empty":        [("_Run", False),
-("_Stop", False)],
-"Broken":       [],
-"Disconnected": [("_Run", False),
-("_Stop", False),
-("_Transfer", False),
-("_Connect", True),
-("_Disconnect", False)],
-}.get(status, []):
-self.ShowMethod(*args)
 self.previous_plcstate = status
 if self.AppFrame is not None:
 updated = True
 self.AppFrame.RefreshStatusToolBar()
 if status == "Disconnected":
-self.AppFrame.ConnectionStatusBar.SetStatusText(self.GetTextStatus(status), 1)
+self.AppFrame.ConnectionStatusBar.SetStatusText(
+self.GetTextStatus(status), 1)
 self.AppFrame.ConnectionStatusBar.SetStatusText('', 2)
 else:
 self.AppFrame.ConnectionStatusBar.SetStatusText(
 _("Connected to URI: %s") % self.BeremizRoot.getURI_location().strip(), 1)
-self.AppFrame.ConnectionStatusBar.SetStatusText(self.GetTextStatus(status), 2)
+self.AppFrame.ConnectionStatusBar.SetStatusText(
+self.GetTextStatus(status), 2)
 return updated
 def GetTextStatus(self, status):
 msgs = {
 "Started":      _("Started"),
 "Stopped":      _("Stopped"),
 "Empty":        _("Empty"),
 "Broken":       _("Broken"),
 "Disconnected": _("Disconnected")
 }
 return msgs.get(status, status)
 def ShowPLCProgress(self, status="", progress=0):
 self.AppFrame.ProgressStatusBar.Show()
-self.AppFrame.ConnectionStatusBar.SetStatusText(self.GetTextStatus(status), 1)
+self.AppFrame.ConnectionStatusBar.SetStatusText(
+self.GetTextStatus(status), 1)
 self.AppFrame.ProgressStatusBar.SetValue(progress)
 def HidePLCProgress(self):
 # clear previous_plcstate to restore status
 # in UpdateMethodsFromPLCStatus()
 self.UpdateMethodsFromPLCStatus()
 def SnapshotAndResetDebugValuesBuffers(self):
 if self._connector is not None:
 plc_status, Traces = self._connector.GetTraceVariables()
-# print [dict.keys() for IECPath, (dict, log, status, fvalue) in self.IECdebug_datas.items()]
+# print [dict.keys() for IECPath, (dict, log, status, fvalue) in
+# self.IECdebug_datas.items()]
 if plc_status == "Started":
 if len(Traces) > 0:
 for debug_tick, debug_buff in Traces:
-debug_vars = UnpackDebugBuffer(debug_buff, self.TracedIECTypes)
+debug_vars = UnpackDebugBuffer(
+debug_buff, self.TracedIECTypes)
 if debug_vars is not None and len(debug_vars) == len(self.TracedIECPath):
 for IECPath, values_buffer, value in izip(
 self.TracedIECPath,
 self.DebugValuesBuffers,
 debug_vars):
-IECdebug_data = self.IECdebug_datas.get(IECPath, None)
+IECdebug_data = self.IECdebug_datas.get(
+IECPath, None)
 if IECdebug_data is not None and value is not None:
-forced = IECdebug_data[2:4] == ["Forced", value]
+forced = IECdebug_data[2:4] == [
+"Forced", value]
 if not IECdebug_data[4] and len(values_buffer) > 0:
 values_buffer[-1] = (value, forced)
 else:
 values_buffer.append((value, forced))
 self.DebugTicks.append(debug_tick)
 # Callable Dict is empty.
 # This variable is not needed anymore!
 IECPathsToPop.append(IECPath)
 elif IECPath != "__tick__":
 # Convert
-Idx, IEC_Type = self._IECPathToIdx.get(IECPath, (None, None))
+Idx, IEC_Type = self._IECPathToIdx.get(
+IECPath, (None, None))
 if Idx is not None:
 if IEC_Type in DebugTypesSize:
 Idxs.append((Idx, IEC_Type, fvalue, IECPath))
 else:
-self.logger.write_warning(_("Debug: Unsupported type to debug '%s'\n") % IEC_Type)
+self.logger.write_warning(
+_("Debug: Unsupported type to debug '%s'\n") % IEC_Type)
 else:
-self.logger.write_warning(_("Debug: Unknown variable '%s'\n") % IECPath)
+self.logger.write_warning(
+_("Debug: Unknown variable '%s'\n") % IECPath)
 for IECPathToPop in IECPathsToPop:
 self.IECdebug_datas.pop(IECPathToPop)
 if Idxs:
 Idxs.sort()
 # Prevent to call RegisterDebugVarToConnector when PLC is not started
 # 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
+# use wx.CallAfter use keep using same thread. TODO : use wx.Timer
-self.DebugTimer = Timer(0.5, wx.CallAfter, args=[self.RegisterDebugVarToConnector])
+# instead
+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))
 debug_ticks, buffers = self.SnapshotAndResetDebugValuesBuffers()
 start_time = time.time()
 if len(self.TracedIECPath) == len(buffers):
 for IECPath, values in izip(self.TracedIECPath, buffers):
 if len(values) > 0:
-self.CallWeakcallables(IECPath, "NewValues", debug_ticks, values)
+self.CallWeakcallables(
+IECPath, "NewValues", debug_ticks, values)
 if len(debug_ticks) > 0:
-self.CallWeakcallables("__tick__", "NewDataAvailable", debug_ticks)
+self.CallWeakcallables(
+"__tick__", "NewDataAvailable", debug_ticks)
 delay = time.time() - start_time
 next_refresh = max(REFRESH_PERIOD - delay, 0.2 * delay)
 if self.DispatchDebugValuesTimer is not None:
 self.DispatchDebugValuesTimer.Start(
 wx.CallAfter(self.UpdateMethodsFromPLCStatus)
 def _Connect(self):
 # don't accept re-connetion if already connected
 if self._connector is not None:
-self.logger.write_error(_("Already connected. Please disconnect\n"))
+self.logger.write_error(
+_("Already connected. Please disconnect\n"))
 return
 # Get connector uri
 uri = self.BeremizRoot.getURI_location().strip()
 # Get connector from uri
 try:
 self._SetConnector(connectors.ConnectorFactory(uri, self))
 except Exception:
-self.logger.write_error(_("Exception while connecting %s!\n") % uri)
+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()
 # Init with actual PLC status and print it
 self.UpdateMethodsFromPLCStatus()
 if self.previous_plcstate in ["Started", "Stopped"]:
 if self.DebugAvailable() and self.GetIECProgramsAndVariables():
 self.logger.write(_("Debugger ready\n"))
 self._connect_debug()
 else:
-self.logger.write_warning(_("Debug does not match PLC - stop/transfert/start to re-enable\n"))
+self.logger.write_warning(
+_("Debug does not match PLC - stop/transfert/start to re-enable\n"))
 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 does not match with target, please transfer.\n"))
+# _("Latest build does not match with target, please
+# transfer.\n"))
 self.EnableMethod("_Transfer", True)
 else:
 # self.logger.write(
 #     _("Latest build matches target, no transfer needed.\n"))
 self.EnableMethod("_Transfer", True)
 # 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"))
+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(
 self.AppFrame.LogViewer.ResetLogCounters()
 else:
 self.logger.write_error(_("Transfer failed\n"))
 self.HidePLCProgress()
 else:
-self.logger.write_error(_("No PLC to transfer (did build succeed ?)\n"))
+self.logger.write_error(
+_("No PLC to transfer (did build succeed ?)\n"))
 wx.CallAfter(self.UpdateMethodsFromPLCStatus)
 StatusMethods = [
 {

changeset 2279	70143c20d2c0
parent 2248	d9353e440887
child 2263	5227f54f6369
child 2415	f7d8891fe708