ramsymbols.py

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

      func.memAddress = self.memAddress
      func.length = self.value["value"].size
    else :
      #if this is an array check if the whole thing will fit in the return msg
      if self.isArray and self.size > self.parent.app.types.ramSymbol_t.data.size :
        raise Exception("Array is too large for peeking.  You must index the peek")
      func.memAddress = self.memAddress
      func.length = self.size
    if func.length > self.parent.app.types.ramSymbol_t.data.size :
      raise Exception("Ram symbol size too large for msg buffer")
    func.dereference = dereference
    result = func(**nameArgs)
    if result != None :
      return map(self.parsePeekResponse, result)

  def parsePeekResponse(self, msg) :
    #create the response message depending on if was rpc error or not
    if msg.nescType == "RpcResponseMsg":
      response = nescDecls.TosMsg(self.memAddress, "PeekErrorMsg",
                                  ("value", self.parent.app.types.result_t))
      response.value=0
      addr = msg.sourceAddress
    else:
      #choose the type depending on if the ramSymbol is the entire symbol or element of array
      if msg.length == self.size and msg.memAddress == self.memAddress :
        if self.isStruct :
          value = deepcopy(self)
        else :
          value = deepcopy(self.value["value"])
      elif (self.isArray and msg.length == self.value["value"].elementType.size and
            (msg.memAddress -self.memAddress) % self.value["value"].elementType.size ==0 and
            msg.memAddress < self.memAddress + self.len * self.value["value"].elementType.size):
        value = deepcopy(self.value["value"].elementType)
      elif (self.isArray and self.isPointer
            and msg.length == self.value["value"].elementType.value.size and
            (msg.memAddress -self.memAddress) % self.value["value"].elementType.value.size ==0 and
            msg.memAddress < self.memAddress + self.len * self.value["value"].elementType.size):
        value = deepcopy(self.value["value"].elementType.value)
      elif (self.isPointer
            and msg.length == self.value["value"].value.size and
            msg.memAddress == self.memAddress ) :
        value = deepcopy(self.value["value"].value)
      else :
        raise Exception("Memory address mismatch in peek response")
      #choose the type depending on whether calling func was peek or ptrPeek
      if self.isPointer :
        if msg.dereference :
          value = value.value
        else :
          value = self.parent.app.types["unsigned int"]
      #create the return message from type depending if it is a struct already or must be created
      if issubclass(type(value), nescDecls.nescStruct) :
        response = nescDecls.TosMsg(self.memAddress, value)
      else :
        response = nescDecls.TosMsg(self.memAddress, value.nescType,
                                    ("value", value))
      bytes = msg.data.getBytes()
      response.setBytes(bytes[:response.size])
      addr = msg.parentMsg.sourceAddress
    response.parentMsg = msg
    response.nescType = "".join( [self.nescType, ".peek(),  nodeID=%d"%addr])
    return response
  
  def __str__(self) :
    if self.isStruct :
      return "%20s : %s\n" % (self.nescType,self.name)
    else:
      return "%20s : %s\n" % (self.value["value"].nescType,self.nescType)

        
  def __deepcopy__(self, memo={}) :
    result = self.__class__()
    memo[id(self)] = result
    result.parent = self.parent
    for (callParam, defaultVal) in self.parent.defaultCallParams :
      result.__dict__[callParam] = deepcopy(self.__dict__[callParam], memo)
    nescDecls.TosMsg.__init__(result, self.amType, self)
    return result    
    
                    
  def registerPeek(self, listener, comm=()) :
    self.parent.app.RamSymbolsM.peek.register(SymbolResponseListener(listener, self.parsePeekResponse), *comm)
    
  def unregisterPeek(self, listener, comm=()) :
    self.parent.app.RamSymbols.peek.unregister(SymbolResponseListener(listener, self.parsePeekResponse), *comm)

  def registerPoke(self, listener, comm=()) :
    self.parent.app.RamSymbolsM.poke.register(SymbolResponseListener(listener, self.parsePokeResponse), *comm)
    
  def unregisterPoke(self, listener, comm=()) :
    self.parent.app.RamSymbols.poke.unregister(SymbolResponseListener(listener, self.parsePokeResponse), *comm)




class SymbolResponseListener( Comm.MessageListener ):

  def __init__(self, callback, parseFunction ):
    self.parseFunction = parseFunction
    Comm.MessageListener.__init__(self, callback)
    self._firstHashFunction = self._hashFunction
    self._hashFunction = self._combinedHash

  def _combinedHash(self):
    return self._firstHashFunction() + self.parseFunction.__hash__()

  def messageReceived( self , addr , msg ) :
    try:
      msg = self.parseFunction(msg)
      self.callback(addr, msg)
    except Exception, e:
      pass
          



  
class RamSymbols( RoutingMessages.RoutingMessages) :
  """A container class from which to find all ram symbols.

  """
  
  def __init__(self, app, sendComm=None, receiveComm=None, tosbase=True, **callParams) :
    """ Find function defs in rpcSchema.xml file and create function objects."""
    if not "ramSymbol_t" in app.types._types :
      print "The RamSymbolsM module was not compiled in.  No ram symbols will be imported."
    RoutingMessages.RoutingMessages.__init__(self, app)

    self.defaultCallParams = ( ("address", None), ("returnAddress", None),
                        ("timeout", 1), ("blocking", True), ("responseDesired", True) )
    self.initializeCallParams(callParams)
    self.tooLarge = []
    self.sizeIncorrect = []
    self.noType = []
    self.arraySizeIncorrect = []
    schema = minidom.parse("%snescDecls.xml" % app.buildDir)
    symbols, = schema.childNodes[0].getElementsByTagName("ramSymbols")
    symbols = [node for node in symbols.childNodes if node.nodeType == 1]
    for symbolDef in symbols: 
      try :
          self._messages[symbolDef.getAttribute("name")] = RamSymbol(symbolDef, self)
      except Exception, e:
          if len(e.args) > 0 and e.args[0].find("No type") == 0:
              self.noType.append(symbolDef)
          elif len(e.args) > 0 and e.args[0].find("Could not discern") == 0:
              self.arraySizeIncorrect.append(symbolDef)
          elif len(e.args) > 0 and e.args[0].find("Ram symbol size too large") == 0:
              self.tooLarge.append(symbolDef)
          elif len(e.args) > 0 and e.args[0].find("Ram symbol size incorrect") == 0:
              self.sizeIncorrect.append(symbolDef)
          else :
              raise
    #self.printSkippedSymbols()
      
  def printSkippedSymbols(self) :
    err = ""
    if len(self.tooLarge) >0 :
      err += "\nWarning: %d ram symbols were too large for %d byte packet.\n" % (len(self.tooLarge), self.app.types.ramSymbol_t.data.size )
      for symbol in self.tooLarge :
        err += "\t%s\n" % symbol.getAttribute("name")
    if len(self.sizeIncorrect) >0 :
      err += "\nWarning: The size of the following ram symbols does not match the size of the discovered type:\n"
      for symbol in self.sizeIncorrect :
        err += "\t%s\n" % symbol.getAttribute("name")
    if len(self.noType) >0 :
      err += "\nWarning: No type was found for the following ram symbols:\n"
      for symbol in self.noType :
        err += "\t%s\n" % symbol.getAttribute("name")
    if len(self.arraySizeIncorrect) >0 :
      err += "\nWarning: The following ram symbols are arrays with length not a multiple of the type size:\n"
      for symbol in self.arraySizeIncorrect :
        err += "\t%s\n" % symbol.getAttribute("name")
    if len(err) > 0 : print err