HskPacketDecoder.py

#!/usr/local/bin/python
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#


__facility__ = "Online"
__abstract__ = "Housekeeping handler client"
__author__   = "Amedeo Perazzo <perazzo@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2004/10/06 20:50:21 $").split(' ')[1]
__version__  = "$Revision: 1.3 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import logging as log

import struct

from LATTE.client.gBits import *

ccsdsFmt = "!LHLL"      # 14 byte header

# Note:  HSK packet length = 116 bytes --> HSK payload = 102 bytes

class ccsdsPacket(object):
  """\brief Interface to a generic CCSDS packet
  
  \param ui The raw binary representation of the packet in big-endian byte order
  
  Methods:
  apid()          return packet APID
  secHead()       return packet secondary header bit
  type()          return packet type bit
  version()       return packet version
  seqCnt()        return sequence count
  seqFlg()        return sequence flag
  length()        return packet length in bytes
  seconds()       return timestamp seconds
  subSeconds()    return timestamp sub seconds
  payload()       return packet payload (opaque)
  
  """
  def __init__(self, ui):
    self.__ui      = ui
    self.__decode()
  
  def __decode(self):
    # print "ccsdspacket:decode string=%d, fmt=%d" % (len(self.__ui[0:14]), struct.calcsize(ccsdsFmt))
    ( header, self.__length, self.__seconds, self.__subSeconds ) = \
      struct.unpack(ccsdsFmt, self.__ui[0:14])
    self.__header  = ccsdsHeader(header)
    self.__payload = self.__ui[14:]
  
  def apid(self):        return self.__header.apid 
  def secHead(self):     return self.__header.secHead
  def type(self):        return self.__header.type
  def version(self):     return self.__header.version
  def seqCnt(self):      return self.__header.seqCnt
  def seqFlg(self):      return self.__header.seqFlg
  def length(self):      return self.__length
  def seconds(self):     return self.__seconds
  def subSeconds(self):  return self.__subSeconds
  def payload(self):     return self.__payload


class ccsdsHeader(BitField):
  """\brief CCSDS Header bitfield definition
  """
  cch_BF = [
             ( 'apid',     0, 11 ),
             ( 'secHead', 11, 12 ),             
             ( 'type',    12, 13 ),  
             ( 'version', 13, 16 ), 
             ( 'seqCnt',  16, 30 ),
             ( 'seqFlg',  30, 32 )
           ]
  def __init__(self, ui):
    BitField.__init__(self, ui, self.cch_BF)


class HskPacketBase(ccsdsPacket):
  def __init__(self, ui):
    ccsdsPacket.__init__(self, ui)
    self.__bitsRead = 0
    # print "HskPacketBase:decode string=%d, fmt=%d" % (len(self.payload()), struct.calcsize('!51H'))
    self.__longArray = struct.unpack('!51H', self.payload())
    
  def __readBits(self, bits): 
    # parse out n bits from the struct.
    # keep a count of the bits read
    if bits >= 16:
      return self.__readBitsBig(bits)
    mask = ( 1 << bits ) - 1
    retVal = ( self.__longArray[self.__bitsRead/16] >> (self.__bitsRead%16) ) & mask
    self.__bitsRead += bits
    return retVal
    
  def __readBitsBig(self, bits):
    # more than 16 bits.  Build an n bit number.
    nChunk = bits/16 + ( bits%16 != 0 )   # True == 1
    chunk = 0
    br = self.__bitsRead/16
    for i in range(nChunk):
      chunk |= long(self.__longArray[br+i]) << ( 16 * (nChunk - i - 1) )
      
    mask = (long(1) << bits) - 1
    
    retVal = ( chunk >> (self.__bitsRead%16) ) & mask
    self.__bitsRead += bits
    return retVal
    
  def read(self):
    for mnem,key in self.mnemList:
      self.__dict__[mnem] = self.__readBits(self.bitDict[key])

def packetFactory(packet):
  # create a hsk class from a packet and return it
  theShort = struct.unpack('!H', packet[0:2])
  apid = theShort[0] & 0x7ff
  classRet = "HskPacket%03x" % apid
  exec('from LATTE.monitoring.HskPacket import ' + classRet)
  classStr = classRet + '(packet)'
  return eval(classStr)


# eof

---