beremiz: comparison ProjectController.py

equal deleted inserted replaced

-:28e9d479aa65
+:de4ee16f7c6c
 from types import ListType
 from threading import Timer, Lock, Thread
 from time import localtime
 from datetime import datetime
 from weakref import WeakKeyDictionary
+from itertools import izip
 import targets
 import connectors
 from util.misc import CheckPathPerm, GetClassImporter
 from util.MiniTextControler import MiniTextControler
 from editors.DebugViewer import DebugViewer, REFRESH_PERIOD
 from dialogs import DiscoveryDialog
 from PLCControler import PLCControler
 from plcopen.structures import IEC_KEYWORDS
 from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels
+from targets.typemapping import UnpackDebugBuffer
 from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage
-base_folder = os.path.split(sys.path[0])[0]
+base_folder = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
 MATIEC_ERROR_MODEL = re.compile(".*\.st:(\d+)-(\d+)\.\.(\d+)-(\d+): (?:error)|(?:warning) : (.*)$")
-DEBUG_RETRIES_WARN = 3
-DEBUG_RETRIES_REREGISTER = 4
 ITEM_CONFNODE = 25
 def ExtractChildrenTypesFromCatalog(catalog):
 children_types = []
 return True
 def _Compile_ST_to_SoftPLC(self):
 self.logger.write(_("Compiling IEC Program into C code...\n"))
 buildpath = self._getBuildPath()
+buildcmd = "\"%s\" -f -l -p -I \"%s\" -T \"%s\" \"%s\""%(
-# Now compile IEC code into many C files
-# files are listed to stdout, and errors to stderr.
-status, result, err_result = ProcessLogger(
-self.logger,
-"\"%s\" -f -l -p -I \"%s\" -T \"%s\" \"%s\""%(
 self.iec2c_path,
 self.ieclib_path,
 buildpath,
-self._getIECcodepath()),
+self._getIECcodepath())
-no_stdout=True, no_stderr=True).spin()
+try:
+# 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()
+except Exception,e:
+self.logger.write_error(buildcmd + "\n")
+self.logger.write_error(repr(e) + "\n")
+return False
 if status:
 # Failed !
 # parse iec2c's error message. if it contains a line number,
 # then print those lines from the generated IEC file.
 Reset variable and program list that are parsed from
 CSV file generated by IEC2C compiler.
 """
 self._ProgramList = None
 self._VariablesList = None
+self._DbgVariablesList = None
 self._IECPathToIdx = {}
 self._Ticktime = 0
 self.TracedIECPath = []
+self.TracedIECTypes = []
 def GetIECProgramsAndVariables(self):
 """
 Parse CSV-like file  VARIABLES.csv resulting from IEC2C compiler.
 Each section is marked with a line staring with '//'
 # describes CSV columns
 ProgramsListAttributeName = ["num", "C_path", "type"]
 VariablesListAttributeName = ["num", "vartype", "IEC_path", "C_path", "type"]
 self._ProgramList = []
 self._VariablesList = []
+self._DbgVariablesList = []
 self._IECPathToIdx = {}
 # Separate sections
 ListGroup = []
 for line in open(csvfile,'r').xreadlines():
 # 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(';')))
 # Truncate "C_path" to remove conf an ressources names
 parts = attrs["C_path"].split(".",2)
 attrs["C_path"] = '__'.join(parts[1:])
 else:
 attrs["C_path"] = '__'.join(parts)
 if attrs["vartype"] == "FB":
 config_FBs[tuple(parts)] = attrs["C_path"]
-# Push this dictionnary into result.
+if attrs["vartype"] != "FB":
+# Push this dictionnary into result.
+self._DbgVariablesList.append(attrs)
+# Fill in IEC<->C translation dicts
+IEC_path=attrs["IEC_path"]
+self._IECPathToIdx[IEC_path]=(Idx, attrs["type"])
+# Ignores numbers given in CSV file
+# Idx=int(attrs["num"])
+# Count variables only, ignore FBs
+Idx+=1
 self._VariablesList.append(attrs)
-# Fill in IEC<->C translation dicts
-IEC_path=attrs["IEC_path"]
-Idx=int(attrs["num"])
-self._IECPathToIdx[IEC_path]=(Idx, attrs["type"])
 # third section contains ticktime
 if len(ListGroup) > 2:
 self._Ticktime = int(ListGroup[2][0])
 Generate trace/debug code out of PLC variable list
 """
 self.GetIECProgramsAndVariables()
 # prepare debug code
-debug_code = targets.GetCode("plc_debug") % {
+variable_decl_array = []
-"buffer_size": reduce(lambda x, y: x + y, [DebugTypesSize.get(v["type"], 0) for v in self._VariablesList], 0),
+bofs = 0
+for v in self._DbgVariablesList :
+sz = DebugTypesSize.get(v["type"], 0)
+variable_decl_array += [
+"{&(%(C_path)s), "%v+
+{"EXT":"%(type)s_P_ENUM",
+"IN":"%(type)s_P_ENUM",
+"MEM":"%(type)s_O_ENUM",
+"OUT":"%(type)s_O_ENUM",
+"VAR":"%(type)s_ENUM"}[v["vartype"]]%v +
+"}"]
+bofs += sz
+debug_code = targets.GetCode("plc_debug.c") % {
+"buffer_size":bofs,
 "programs_declarations":
 "\n".join(["extern %(type)s %(C_path)s;"%p for p in self._ProgramList]),
 "extern_variables_declarations":"\n".join([
 {"EXT":"extern __IEC_%(type)s_p %(C_path)s;",
 "IN":"extern __IEC_%(type)s_p %(C_path)s;",
 "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_each_variable_do_code":"\n".join([
+"variable_decl_array": ",\n".join(variable_decl_array)
-{"EXT":"    (*fp)((void*)&(%(C_path)s),%(type)s_P_ENUM);\n",
+}
-"IN":"    (*fp)((void*)&(%(C_path)s),%(type)s_P_ENUM);\n",
-"MEM":"    (*fp)((void*)&(%(C_path)s),%(type)s_O_ENUM);\n",
-"OUT":"    (*fp)((void*)&(%(C_path)s),%(type)s_O_ENUM);\n",
-"VAR":"    (*fp)((void*)&(%(C_path)s),%(type)s_ENUM);\n"}[v["vartype"]]%v
-for v in self._VariablesList if v["vartype"] != "FB" and v["type"] in DebugTypesSize ]),
-"find_variable_case_code":"\n".join([
-"    case %(num)s:\n"%v+
-"        *varp = (void*)&(%(C_path)s);\n"%v+
-{"EXT":"        return %(type)s_P_ENUM;\n",
-"IN":"        return %(type)s_P_ENUM;\n",
-"MEM":"        return %(type)s_O_ENUM;\n",
-"OUT":"        return %(type)s_O_ENUM;\n",
-"VAR":"        return %(type)s_ENUM;\n"}[v["vartype"]]%v
-for v in self._VariablesList if v["vartype"] != "FB" and v["type"] in DebugTypesSize ])}
 return debug_code
 def Generate_plc_main(self):
 """
 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
 if not self.BeremizRoot.getDisable_Extensions():
-plc_main_code = targets.GetCode("plc_main_head") % {
+plc_main_code = targets.GetCode("plc_main_head.c") % {
 "calls_prototypes":"\n".join([(
 "int __init_%(s)s(int argc,char **argv);\n"+
 "void __cleanup_%(s)s(void);\n"+
 "void __retrieve_%(s)s(void);\n"+
 "void __publish_%(s)s(void);")%{'s':locstr} for locstr in locstrs]),
 "cleanup_calls":"\n    ".join([
 "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") % {
+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.GetCode("plc_main_tail")
+plc_main_code += targets.GetCode("plc_main_tail.c")
 return plc_main_code
 def _Build(self):
 """
 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 =  CTNLocationCFilesAndCFLAGS + LibCFilesAndCFLAGS
+self.LocationCFilesAndCFLAGS =  LibCFilesAndCFLAGS + CTNLocationCFilesAndCFLAGS
 self.LDFLAGS = CTNLDFLAGS + LibLDFLAGS
 ExtraFiles = CTNExtraFiles + LibExtraFiles
 # Get temporary directory path
 extrafilespath = self._getExtraFilesPath()
 def PullPLCStatusProc(self, event):
 self.UpdateMethodsFromPLCStatus()
 def SnapshotAndResetDebugValuesBuffers(self):
 buffers, self.DebugValuesBuffers = (self.DebugValuesBuffers,
-[list() for iec_path in self.TracedIECPath])
+[list() for n in xrange(len(self.TracedIECPath))])
 ticks, self.DebugTicks = self.DebugTicks, []
 return ticks, buffers
 def RegisterDebugVarToConnector(self):
 self.DebugTimer=None
 Idxs = []
 self.TracedIECPath = []
+self.TracedIECTypes = []
 if self._connector is not None:
 self.IECdebug_lock.acquire()
 IECPathsToPop = []
 for IECPath,data_tuple in self.IECdebug_datas.iteritems():
 WeakCallableDict, data_log, status, fvalue, buffer_list = data_tuple
 for IECPathToPop in IECPathsToPop:
 self.IECdebug_datas.pop(IECPathToPop)
 if Idxs:
 Idxs.sort()
-self.TracedIECPath = zip(*Idxs)[3]
+IdxsT = zip(*Idxs)
-self._connector.SetTraceVariablesList(zip(*zip(*Idxs)[0:3]))
+self.TracedIECPath = IdxsT[3]
+self.TracedIECTypes = IdxsT[1]
+self._connector.SetTraceVariablesList(zip(*IdxsT[0:3]))
 else:
 self.TracedIECPath = []
 self._connector.SetTraceVariablesList([])
 self.SnapshotAndResetDebugValuesBuffers()
 self.IECdebug_lock.release()
 def GetDebugIECVariableType(self, IECPath):
 Idx, IEC_Type = self._IECPathToIdx.get(IECPath,(None,None))
 return IEC_Type
-def SubscribeDebugIECVariable(self, IECPath, callableobj, buffer_list=False, *args, **kwargs):
+def SubscribeDebugIECVariable(self, IECPath, callableobj, buffer_list=False):
 """
 Dispatching use a dictionnary linking IEC variable paths
 to a WeakKeyDictionary linking
-weakly referenced callables to optionnal args
+weakly referenced callables
 """
 if IECPath != "__tick__" and not self._IECPathToIdx.has_key(IECPath):
 return None
 self.IECdebug_lock.acquire()
 buffer_list]                # Forced value
 self.IECdebug_datas[IECPath] = IECdebug_data
 else:
 IECdebug_data[4] |= buffer_list
-IECdebug_data[0][callableobj]=(buffer_list, args, kwargs)
+IECdebug_data[0][callableobj]=buffer_list
 self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 if len(IECdebug_data[0]) == 0:
 self.IECdebug_datas.pop(IECPath)
 else:
 IECdebug_data[4] = reduce(
 lambda x, y: x|y,
-[buffer_list for buffer_list,args,kwargs
+IECdebug_data[0].itervalues(),
-in IECdebug_data[0].itervalues()],
 False)
 self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def CallWeakcallables(self, IECPath, function_name, *cargs):
 data_tuple = self.IECdebug_datas.get(IECPath, None)
 if data_tuple is not None:
 WeakCallableDict, data_log, status, fvalue, buffer_list = data_tuple
 #data_log.append((debug_tick, value))
-for weakcallable,(buffer_list,args,kwargs) in WeakCallableDict.iteritems():
+for weakcallable,buffer_list in WeakCallableDict.iteritems():
 function = getattr(weakcallable, function_name, None)
 if function is not None:
 if buffer_list:
-function(*(cargs + args), **kwargs)
+function(*cargs)
 else:
-function(*(tuple([lst[-1] for lst in cargs]) + args), **kwargs)
+function(*tuple([lst[-1] for lst in cargs]))
 def GetTicktime(self):
 return self._Ticktime
 def RemoteExec(self, script, **kwargs):
 This thread waid PLC debug data, and dispatch them to subscribers
 """
 self.debug_break = False
 debug_getvar_retry = 0
 while (not self.debug_break) and (self._connector is not None):
-Trace = self._connector.GetTraceVariables()
+plc_status, Traces = self._connector.GetTraceVariables()
-if(Trace):
-plc_status, debug_tick, debug_vars = Trace
-else:
-plc_status = None
 debug_getvar_retry += 1
 #print [dict.keys() for IECPath, (dict, log, status, fvalue) in self.IECdebug_datas.items()]
-if plc_status == "Started":
+if plc_status == "Started" :
-self.IECdebug_lock.acquire()
+if len(Traces) > 0:
-if (debug_tick is not None and
+Failed = False
-len(debug_vars) == len(self.DebugValuesBuffers) and
+self.IECdebug_lock.acquire()
-len(debug_vars) == len(self.TracedIECPath)):
+for debug_tick, debug_buff in Traces :
-if debug_getvar_retry > DEBUG_RETRIES_WARN:
+debug_vars = UnpackDebugBuffer(debug_buff, self.TracedIECTypes)
-self.logger.write(_("... debugger recovered\n"))
+if (debug_vars is not None and
-debug_getvar_retry = 0
+len(debug_vars) == len(self.TracedIECPath)):
-for IECPath, values_buffer, value in zip(self.TracedIECPath, self.DebugValuesBuffers, debug_vars):
+for IECPath, values_buffer, value in izip(
-IECdebug_data = self.IECdebug_datas.get(IECPath, None)
+self.TracedIECPath,
-if IECdebug_data is not None and value is not None:
+self.DebugValuesBuffers,
-forced = IECdebug_data[2:4] == ["Forced", value]
+debug_vars):
-if not IECdebug_data[4] and len(values_buffer) > 0:
+IECdebug_data = self.IECdebug_datas.get(IECPath, None) #FIXME get
-values_buffer[-1] = (value, forced)
+if IECdebug_data is not None and value is not None:
-else:
+forced = IECdebug_data[2:4] == ["Forced", value]
-values_buffer.append((value, forced))
+if not IECdebug_data[4] and len(values_buffer) > 0:
-self.DebugTicks.append(debug_tick)
+values_buffer[-1] = (value, forced)
-self.IECdebug_lock.release()
+else:
-if debug_getvar_retry == DEBUG_RETRIES_WARN:
+values_buffer.append((value, forced))
-self.logger.write(_("Waiting debugger to recover...\n"))
+self.DebugTicks.append(debug_tick)
-if debug_getvar_retry == DEBUG_RETRIES_REREGISTER:
+debug_getvar_retry = 0
-# re-register debug registry to PLC
+self.IECdebug_lock.release()
-wx.CallAfter(self.RegisterDebugVarToConnector)
 if debug_getvar_retry != 0:
-# Be patient, tollerate PLC to come up before debugging
+# Be patient, tollerate PLC to come with fresh samples
 time.sleep(0.1)
 else:
 self.debug_break = True
 self.logger.write(_("Debugger disabled\n"))
 self.DebugThread = None
 self.IECdebug_lock.acquire()
 debug_ticks, buffers = self.SnapshotAndResetDebugValuesBuffers()
 self.IECdebug_lock.release()
 start_time = time.time()
 if len(self.TracedIECPath) == len(buffers):
-for IECPath, values in zip(self.TracedIECPath, buffers):
+for IECPath, values in izip(self.TracedIECPath, buffers):
 if len(values) > 0:
 self.CallWeakcallables(IECPath, "NewValues", debug_ticks, values)
 if len(debug_ticks) > 0:
 self.CallWeakcallables("__tick__", "NewDataAvailable", debug_ticks)

changeset 1475	de4ee16f7c6c
parent 1451	94e620cbd9de
child 1484	d5efbb20927e