SimpleEPUtest.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Simple test of converted EPU"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2006/01/10 00:08:27"
__updated__  = "$Date: 2006/03/08 00:40:22 $"
__version__  = "$Revision: 1.6 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import logging as log
import            os
import            time
from   binascii import hexlify
import struct


from LICOS_Scripts.lib.testAppBase               import TestAppBase
from LICOS.lib.cmdTlmDb.TelemetryEvent         import TelemetryEvent
from LICOS.lib.LATconstants                    import *
from LICOS.lib.cmdTlmDb.PBC                    import *
from LICOS.lib.cmdTlmDb.FILE                    import *
import VSC


#  Example application implementation.
class SimpleEPUtest(TestAppBase):
  """\brief LAT startup sequence testing.

  """
  def __init__(self, common):
    TestAppBase.__init__(self, common)
    log.debug("%s.__init__()" % self.getName())

    self.__prefDir = os.path.join(ONLINE_ROOT, 'LICOS/tests/data')
    self.__prefPrompt = "Select EPU test configuration"
    preReqSeq = []

  def getName(self):
    return self.__class__.__name__

  def testSetup(self):
    #self.testScriptPrefs = self.readTestscriptPreferences(self.__prefDir, self.__prefPrompt)
    #if self.testScriptPrefs is None:
    #  log.debug("Operator cancelled configuration file selection")
    #  return -1


    self.__siuId  = 0
    self.__epuId  = 0
    self.__pduId  = None

    self.vsc.siuSelect(getattr(self.vsc, 'AB'))
    self.vsc.daqSelect(getattr(self.vsc, 'AA'))


  def testStartRun(self):
    pass

  def testRun(self):
    log.debug("%s.startRun()" % self.getName())
    self.setCompletionStatus(self.COMPL_STATUS_UNDEFINED)

    result = True
    try:
      log.info("sending SSR off and load-shed")
      # self.lcat.PBC.LPBCRESET(LPBCLATUNIT=self.__epuId+1,
      #                         LPBCPAD1=0,
      #                         LPBCPAD2=0,
      #                         LPBCPRIFLAGSHI=0,
      #                         LPBCPRIFLAGSLO=0)

      self.vsc.ssr(VSC.VscProxy.Disable)
      time.sleep(2)  # just making sure.

      self.lcat.LIM.LIMLOADSHED()
      time.sleep(15)  # 15 seconds or so for load shed to go through

      log.info("Waiting for SIU boot telemetry")
      result &= self.waitForSiuBootTelem()
      if not result:
        raise "Timeout waiting for primary boot"

      log.info("Secondary booting SIU")
      result &= self.bootSIU()
      if not result:
        raise "bad result in secondary boot"

      log.info("Waiting for LHK...")
      result &= self.waitForLatHSK()
      if not result:
        raise "timeout waiting for LAT telem"

      time.sleep(5)

      log.info("Sending MainFeed, and enabling SSR")
      result &= self.sendMainFeed()
      if not result:
        raise "Bad result in mainfeed"

      time.sleep(5)

      log.info("Sending Power-on to EPU")
      result &= self.powerEPU()
      if not result:
        raise "Bad result in powerEPU"

      log.info("Waiting for EPU boot telemetry")
      result &= self.waitForEpuBootTelem()
      if not result:
        raise "Timeout waiting for EPU boot telem"

      log.info("Attempting to upload to EPU during primary boot")
      result &= self.uplFileEPUpri()


      log.info("Sending Secondary EPU boot")
      result &= self.bootEPU()
      if not result:
        raise "Bad result in bootEPU"

      time.sleep(15)
#      log.info("Attempting to download serial number from EPU %d" % self.__epuId)
#      result &= self.checkEpuMem()

      log.info("attempting to upload file during secondary boot")
      result &= self.uplFileEPUsec()



    except self.StopRequestedException, e:
      msg = ("%s was aborted by the operator while executing step: %s - %s, test: %s"
                  % (self.getName(), e.args[1], e.args[2], e.args[3]))
      log.error(msg)
      result = False
      self.setCompletionStatus(self.COMPL_STATUS_ABORTED)
    else:
      if not result:
        log.error("One or more of the previous tests failed.")
        log.error("Setting status to *****FAILED******")
        self.setCompletionStatus(self.COMPL_STATUS_FAILED)
      else:
        self.setCompletionStatus(self.COMPL_STATUS_PASSED)
    # End of run
    return



  def testStopRun(self):
    pass

  def bootSIU(self):
    result = True
    log.debug("Sending secondary boot command to SIU %d..." % self.__siuId)
    # boot the following:
    #  RTOS_source    = UPPER (1)
    #  SBC executable = UPPER (1)
    #  RTOS database  = RAM   (0)
    # flags_hi = 0x5400 # regular SBC upper bank default boot
    # flags_hi = 0x5000 # VXW, SBC_NOM, DDT
    flags_hi = 0x5400
    flags_hi = 0xA800
    # flags_lo = 0xC000 # Mount EE0, EE1 as file systems
    flags_lo = 0xC000
    self.vsc.bootSIU(0, flags_hi, flags_lo )
    return result

  def powerEPU(self):
    result = True
    self.vsc.powerOnEpuOnly(epuId = self.__epuId, pduId = 0)

    return result


  def bootEPU(self):
    result = True

    # boot the following:
    #  RTOS_source    = UPPER (1)
    #  SBC executable = UPPER (1)
    #  RTOS database  = RAM   (0)
    # flags_hi = 0x5400 # regular SBC upper bank default boot
    # flags_hi = 0x5000 # VXW, SBC_NOM, DDT
    PBC = self.lcat.PBC
    flags_hi = 0x5400
    flags_hi = 0xA800
    flags_hi = 0x8800
    # flags_lo = 0xC000 # Mount EE0, EE1 as file systems
    flags_lo = 0xC000
    PBC.LPBCRTOSEXEC(LPBCLATUNIT = self.__epuId+1,
                     LPBCPAD1    = 0,
                     LPBCPAD2    = 0,
                     LPBCSBCFLAGSHI = flags_hi,
                     LPBCSBCFLAGSLO = flags_lo)


    return result

  def sendMainFeed(self):
    result = True
    # MainFeedOn command with siuId=0, pduId=0, mfPri=1, dabPri=1, dabRed=0
    self.vsc.mainFeedOn( siuId = self.__siuId,
                         pduId = 0,#self.__pduId,
                         mfPri = 1,
                         dabPri = 1,
                         dabRed = 0)
    self.vsc.ssr(VSC.VscProxy.Enable)
    time.sleep(3)
    return result


  def waitForLatHSK(self):
    result = True
    latHskTlm  = TelemetryEvent(self.getTelemHandler(),
                                range(0x210, 0x231))
    latHskTlm.enable()
    log.info("Waiting for LAT housekeeping telemetry...")
    payloads = latHskTlm.waitForPayload([], LONG_TIMEOUT)
    latHskTlm.disable()
    if payloads is not None:
      msg = "LAT housekeeping telemetry received."
      log.info(msg)
    else:
      msg = "LAT housekeeping telemetry is not present."
      log.warning(msg)
      result = False
    return result

  def waitForSiuBootTelem(self):
    siuId = self.__siuId
    log.info("Waiting for SIU %d boot telemetry..." % siuId)
    result = True
    siuBootTlm  = TelemetryEvent(self.getTelemHandler(),
                                 [self.lcatTlm.getApidFromName('LBTHKP')])
    bootMode = None
    siuBootTlm.enable()
    payloads = siuBootTlm.waitForPayload(["LPBCBOOTSTAT"], STANDARD_TIMEOUT)
    siuBootTlm.disable()
    if payloads is not None:
      bootMode = payloads[0]
      if bootMode == PBC.BOOT_MODE_COMMAND:
        msg = "SIU boot telemetry received."
        log.info(msg)
    else:
      msg = "SIU boot telemetry is not present."
      log.warning(msg)
      result = False
      return result
    if bootMode != PBC.BOOT_MODE_COMMAND:
      msg = "SIU boot telemetry received but the boot code mode has unexpected value %s" % PBC.BOOT_CODE_MODES[bootMode]
      log.warning(msg)
      result = False
    return result

  def waitForEpuBootTelem(self):
    epuId = self.__epuId
    result = True
    siuBootTlm  = TelemetryEvent(self.getDiagHandler(),
                                 [self.lcatTlm.getApidFromName('LBTEPU%dHKP'%(epuId))])
    bootMode = None
    siuBootTlm.enable()
    payloads = siuBootTlm.waitForPayload(["LPBC%dBOOTSTAT"%(epuId)], STANDARD_TIMEOUT)
    siuBootTlm.disable()
    if payloads is not None:
      bootMode = payloads[0]
      if bootMode == PBC.BOOT_MODE_COMMAND:
        msg = "EPU boot telemetry received."
        log.info(msg)
    else:
      msg = "EPU boot telemetry is not present."
      log.warning(msg)
      result = False
      return result
    if bootMode != PBC.BOOT_MODE_COMMAND:
      msg = "EPU boot telemetry received but the boot code mode has unexpected value %s" % PBC.BOOT_CODE_MODES[bootMode]
      log.warning(msg)
      result = False
    return result

  def checkEpuMem(self):
    result = True
    return result
    MEM = self.lcat.MEM

    dumpSize = 4
    serialOffsets = (0x10bf0+12, 0x203f0+12, 0x2fbf0+12, 0x3f3f0+12)
    unit = FSW_UNIT_NAMES.index('EPU%d'%self.__epuId)
    epuDump = {}

    for offset in serialOffsets:
      dump = MEM.dumpMemory(unit    = unit,
                                       address = MEM_SUROM_START+offset,
                                       size    = dumpSize/4,
                                       tranID  = 0xBEEF,
                                       dest    = FSW_DEST_1553)
      epuDump[offset] = struct.unpack('!L', dump)


    baseSer = None
    base    = None
    for offset, serial in epuDump.items():
      if baseSer is None:
        baseSer = serial
        base    = offset
        continue
      if serial != baseSer:
        log.error("Serial numbers at memory locations 0x%08x and 0x%08x do not match" % (base, offset))
        log.error("Downloaded serials are 0x%08x and 0x%08x respectively" % (baseSer, serial))
        result = False
        return

    caption = "Input requested"
    msg     = "Downloaded serial number 0x%08x.  \nIf this is correct, press OK" % baseSer
    result = ( self.getInput(caption, msg, None) is not None )


    return result




  def uplFileEPUpri(self):
    self.lcat.FILE.setPrimaryBoot(True)

    #fn = os.path.expandvars("$ONLINE_ROOT/LICOS/tests/data/12346_hdr")
    fn = os.path.join("/nfs/home/panetta/burning/B0-6-1.2",
#                      "fdb/VXW/V6-11-2/vxw_flight/vxw_flight.o.s.z.f")
                      "fdb/SBC/V1-3-1/sbc_nominal/libsbc_nominal.o.s.z.f")
#                      "FDB_sbs_epu.o.z.f")

    fid = FswFileID(device=FSW_DEVICE_BOOT,
                    directory = 0,
                    fileNumber = 1)

    uplF = FswFileFromDisk(fid, fn)

    result = self.lcat.FILE.uploadFile(fswFile = uplF,unit=self.__epuId+1)

    return result


  def uplFileEPUsec(self):
    self.lcat.FILE.setPrimaryBoot(False)

    fn = os.path.join(ONLINE_ROOT, "LICOS/tests/data/12346_hdr")

    fid = FswFileID(device=FSW_DEVICE_RAM,
                    directory = 14,
                    fileNumber = 7)

    uplF = FswFileFromDisk(fid, fn)

    result = self.lcat.FILE.uploadFile(fswFile = uplF,unit=self.__epuId+1)

    dump = self.lcat.FILE.dumpDirectory(self.__epuId+1,fid)
    import sys
    dump.dump(sys.stdout)

    f2 = FswFileID(device=FSW_DEVICE_BOOT,
                    directory = 0,
                    fileNumber = 7)

    dump = self.lcat.FILE.dumpDirectory(self.__epuId+1,f2)
    import sys
    dump.dump(sys.stdout)

    return result

---