/*
 * Communication to DPU
 */

package mxgstest.mxgs;

import asim.envsim.dhpu.Tm;
import asim.envsim.dhpu.tmutils.ParameterValueEvent;
import asim.envsim.dhpu.tmutils.ParameterValueFilter;
import java.util.logging.Logger;
import mxgsegse.MXGSEGSE;
import mxgstest.Output;
import mxgstest.egse.Basic;


/**
 *
 * @author stet
 */
public class Dpu {
    
    Output output = new Output();
    
    static final String ANSI_RESET = "\u001B[0m";
    static final String ANSI_BLACK = "\u001B[30m";
    static final String ANSI_RED = "\u001B[31m";
    static final String ANSI_GREEN = "\u001B[32m";
    static final String ANSI_YELLOW = "\u001B[33m";
    static final String ANSI_BLUE = "\u001B[34m";
    static final String ANSI_PURPLE = "\u001B[35m";
    static final String ANSI_CYAN = "\u001B[36m";
    static final String ANSI_WHITE = "\u001B[37m";
    
    static String stepResult;
    static String stepComment;
    static boolean stepErr;
    
    /** 
     * Send StartCycleRequestTC.
     * @param egse
     * @throws Throwable
     * @author stet
     */
    public void sendStartCycleRequestTc(MXGSEGSE egse) throws Throwable {
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("StartCycleRequestTC"));
    }
        
    /**
    *   Verifies that an empty EDLF frame is received after non science request.
    * @author egse
     * @param egse
     * @throws java.lang.Throwable
     * @author stet
    */
    public void verifyEmptyEDLFNonScience(MXGSEGSE egse) throws Throwable {
        Basic basic = new Basic();
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("NonscienceRequestTC"));
        basic.verifyEmptyEDLF(egse);
        System.out.println("  Verify on Scope..");
    }
    
    /**
    *   Verifies that an empty EDLF frame is received after science request.
    * @author egse
     * @param egse
     * @throws java.lang.Throwable
     * @author stet
    */
    public void verifyEmptyEDLFScience(MXGSEGSE egse) throws Throwable {
        Basic basic = new Basic();
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("ScienceRequestTC"));
        basic.verifyEmptyEDLF(egse);
        System.out.println("  Verify on Scope..");
    }

    

    /**
     *
     * @param egse 
     * @param wait
     * @param nofevents
     * @param eventids
     * @param gc
     * @param acknowledgeSuccessCompl
     * @param result
     * @throws Throwable
     */
    public void verifyEnableInstrumentEventTc(MXGSEGSE egse, double wait, String nofevents, String eventids[], String gc, String acknowledgeSuccessCompl, int result) throws Throwable {
        //Create the Nonscience queue and filter Command verification report (0x10):
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        //Set parameters:
        String commandLength=String.valueOf(5+Integer.valueOf(nofevents));
        egse.packetTool.setTcParameter("EnableInstrumentEventTC", "Command Length", commandLength);
        egse.packetTool.setTcParameter("EnableInstrumentEventTC", "Packet Data.Nof Events", nofevents);
        for (int i=0; i<Integer.valueOf(nofevents); i++) {
            egse.packetTool.setTcParameter("EnableInstrumentEventTC", "Packet Data.Event IDs", i, eventids[i]);
        }
        egse.packetTool.setTcParameter("EnableInstrumentEventTC", "Packet Data.Generation Control",gc);
        egse.packetTool.setTcParameter("EnableInstrumentEventTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", acknowledgeSuccessCompl);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnableInstrumentEventTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received (Timeout).");
            resultCode = 0;
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if (result != resultCode) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing Result. Expected: "+result+". Recieved: "+resultCode);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Enable Instrument Event: "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }

    /**
     *
     * @param egse
     * @throws Throwable
     */
    public void sendEnterConfigurationModeTc(MXGSEGSE egse) throws Throwable {
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnterConfigurationModeTC"));
    }
    
    /**
     *
     * @param egse
     * @throws Throwable
     */
    public void sendEnterOperationalModeTc(MXGSEGSE egse) throws Throwable {
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnterOperationalModeTC"));
    }
    

    /**
     *
     * @param egse
     * @param wait
     * @param acknowledgeSuccessCompl
     * @param result
     * @throws Throwable
     */
    public void verifyEnterOperationalMode(MXGSEGSE egse, double wait, int result) throws Throwable {
        //Create the Nonscience queue:
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnterOperationalModeTC"));
        //Wait for Non science respone.
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from verifyEnterOperationalMode "+ANSI_RED+"(Timeout)."+ANSI_RESET);
            resultCode = 0;
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if (result != resultCode) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing Result. Expected: "+result+". Recieved: "+resultCode);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Enable Instrument Event for Event ID="+resultCode+": "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
 
    /**
     *
     * @param egse
     * @param wait
     * @param memoryID
     * @param writeControl
     * @param acknowledgeSuccessCompl
     * @param result
     * @throws Throwable
     */
    public void verifyEnableMemoryLoadTc(MXGSEGSE egse, double wait, String memoryID, String writeControl, String acknowledgeSuccessCompl, int result) throws Throwable {
//        System.out.println("  Performing: verifyEnableMemoryLoadTc");
         //Look for verification report only
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        egse.packetTool.setTcParameter("EnableMemoryLoadTC", "Packet Data.Write Control", writeControl);
        egse.packetTool.setTcParameter("EnableMemoryLoadTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("EnableMemoryLoadTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", acknowledgeSuccessCompl);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnableMemoryLoadTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from EnableMemoryLoadTC (Timeout).");
            resultCode = 0;
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if (result != resultCode) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing EnableMemoryLoadTC. "+ANSI_RED+"Expected: "+result+". Received: "+resultCode+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Enable Memory Load for Memory ID="+memoryID+": "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    /**
     *
     * @param egse
     * @param wait
     * @param memoryID
     * @param startAddress
     * @param loadData
     * @param cmdLength
     * @param acknowledgeSuccessCompl
     * @param result
     * @throws Throwable
     */
    public void verifyLoadMemoryTc(MXGSEGSE egse, double wait, String memoryID, String startAddress, String loadData, String cmdLength, String acknowledgeSuccessCompl, int result) throws Throwable {
//        System.out.println("  Performing: verifyLoadMemoryTc");
        egse.dhpu.getNonscienceTm().clear();
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        egse.packetTool.setTcParameter("LoadMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("LoadMemoryTC", "Packet Data.Start Address", startAddress);
        egse.packetTool.setTcParameter("LoadMemoryTC", "Packet Data.Load Data", loadData);
        egse.packetTool.setTcParameter("LoadMemoryTC", "Command Length", cmdLength);
        egse.packetTool.setTcParameter("LoadMemoryTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", acknowledgeSuccessCompl);
        Thread.sleep(1000);
        hkTm.clear();
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("LoadMemoryTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from LoadMemoryTC (Timeout).");
            resultCode = 0;
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if (result != resultCode) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing LoadMemoryTC. "+ANSI_RED+"Expected: "+result+". Recieved: "+resultCode+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Load Memory ID="+memoryID+": "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    /**
     * Send DumpMemoryTC and wait for a single Non-ScienceTM. Verify result.
     * @param egse
     * @param wait
     * @param memoryID
     * @param startAddr
     * @param nofOct
     * @param dumpFreq
     * @param dumpResult
     * @throws Throwable
     */
    public void verifyDumpMemoryTc(MXGSEGSE egse, double wait, String memoryID, String startAddr, String nofOct, String dumpFreq, String dumpResult) throws Throwable {
//        System.out.println("  Performing: verifyDumpMemoryTc");
        egse.dhpu.getNonscienceTm().clear();
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Start Address", startAddr);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Nof Octets", nofOct);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Dump Frequency", dumpFreq);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("DumpMemoryTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump for Memory ID="+memoryID+": "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump for ID "+memoryID+" received", stepResult, stepComment, stepErr);
        
        String dumpData = String.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Dump Data"));
        if(!dumpResult.equals(dumpData)){
            stepErr=false;
            stepResult="Failed";
            stepComment="";
            System.out.println("  Failed comparing Result. Expected: "+dumpResult+" Received: "+dumpData);
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Dump Memory for Memory ID="+memoryID+": "+ANSI_GREEN+"Correct"+ANSI_RESET);
        }
        output.printStepOut("Dump Data", dumpResult, dumpData, stepResult, stepComment, stepErr);
    }
    
    /**
     * Send DumpMemoryTC and wait for a single Non-ScienceTM. Verify result.
     * @param egse
     * @param wait
     * @param memoryID
     * @param startAddr
     * @param nofOct
     * @param dumpFreq
     * @param dumpResult
     * @throws Throwable
     */
    public void verifyLongDumpMemoryTc(MXGSEGSE egse, double wait, String memoryID, String startAddr, String nofOct, String dumpFreq, String dumpResult) throws Throwable {
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        hkTm.clear();
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Start Address", startAddr);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Nof Octets", nofOct);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Dump Frequency", dumpFreq);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("DumpMemoryTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump for Memory ID="+memoryID+": "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        int queueSizeOld = 0;
        int queueSize = hkTm.size();
        while(queueSizeOld!=queueSize) {
            Thread.sleep(3000);
            queueSizeOld=queueSize;
            queueSize = hkTm.size();
            System.out.println("Memory Dump QueueSize: "+queueSize);
        }
        Thread.sleep(1000);
        String dumpData = "0x[";
        String curDumpData;
        while(queueSize > 0) {
            curDumpData = String.valueOf(egse.packetTool.getTmParameter(hkTm.removeFirst(), "Packet Data.Dump Data"));
            curDumpData = curDumpData.substring(3, curDumpData.length()-1);
            dumpData = dumpData + curDumpData;
            queueSize--;
        }
        dumpData = dumpData + "]";
        output.printStepOut("Memory Dump for ID "+memoryID+" received", stepResult, stepComment, stepErr);
        for(int i=0;i<dumpData.length()/2;i++) {
            if(!dumpResult.substring(2*i,2*i+1).equals(dumpData.substring(2*i, 2*i+1))){
                System.out.println("Error: "+i+" "+dumpResult.substring(2*i,2*i+1)+" "+dumpData.substring(2*i, 2*i+1));
            }
        }
        if(!dumpResult.equals(dumpData)){
            stepErr=false;
            stepResult="Failed";
            stepComment="";
            System.out.println("  Failed comparing Result. Expected: "+dumpResult+" Received: "+dumpData);
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Dump Memory for Memory ID="+memoryID+": "+ANSI_GREEN+"Correct"+ANSI_RESET);
        }
        output.printStepOut("Dump Data", stepResult, stepComment, stepErr);
    }
    
    /**
     * Send DumpMemoryTC and wait for a single Non-ScienceTM. Verify result.
     * @param egse
     * @param wait
     * @param memoryID
     * @param startAddr
     * @param nofOct
     * @param dumpFreq
     * @param result
     * @throws Throwable
     */
    public void verifyDumpMemoryTc(MXGSEGSE egse, double wait, String memoryID, String startAddr, String nofOct, String dumpFreq, int result) throws Throwable {
        egse.dhpu.getNonscienceTm().clear();
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        ParameterValueEvent hkEvent1 = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm1 = new ParameterValueFilter(hkEvent1, Logger.global);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Start Address", startAddr);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Nof Octets", nofOct);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Dump Frequency", dumpFreq);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", "1");
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("DumpMemoryTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
            resultCode = 0;
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if (result != resultCode) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing DumpMemoryTC. Expected: "+result+". Recieved: "+resultCode);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Dump Memory ID="+memoryID+": "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        if(result!=1) {
            output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
        } else {
            while((hkTm1.size() < 1) && (wait > 0)) {
                Thread.sleep(100);
                wait=wait-0.1;
            }
            if(wait <= 0){
                stepErr=false;
                stepResult="Failed";
                stepComment="No response (Timeout)";
                System.out.println("No response received from DumpMemoryTC (Timeout).");
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Memory dump for Memory ID="+memoryID+": "+ANSI_GREEN+"Received"+ANSI_RESET);
            }
            output.printStepOut("Memory Dump for ID "+memoryID+" received", stepResult, stepComment, stepErr);
        }
    }
    
    /**
     * Send DumpMemoryTC and wait for a single Non-ScienceTM. Verify result.
     * @param egse
     * @param wait
     * @throws Throwable
     */
    public void verifyDumpMemoryReceiving(MXGSEGSE egse, double wait) throws Throwable {
        egse.dhpu.getNonscienceTm().clear();
        ParameterValueEvent hkEvent1 = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm1 = new ParameterValueFilter(hkEvent1, Logger.global);
        while((hkTm1.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait=wait-0.1;
        }
        if(wait <= 0){
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump: "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump received", stepResult, stepComment, stepErr);
    }
    
    
    /**
     * Send a Dump Memory TC.
     * @param egse
     * @param memoryID
     * @param startAddr
     * @param nofOct
     * @param dumpFreq
     * @throws Throwable
     */
    public void sendDumpMemoryTc(MXGSEGSE egse, String memoryID, String startAddr, String nofOct, String dumpFreq) throws Throwable {
//        System.out.println("  Performing: sendDumpMemoryTc");
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Start Address", startAddr);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Nof Octets", nofOct);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Dump Frequency", dumpFreq);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("DumpMemoryTC"));
    }
    
    /**
     * Verify a large memory dump. The size of the memory dump is compared to the expect number of octet to receive. Use a large value for wait for large memory dumps.
     * @param egse
     * @param wait  time to wait in seconds - use a long wait time for large memory dumps.
     * @param memoryID
     * @param startAddr
     * @param nofOct number of octets to dump from memory
     * @param dumpFreq
     * @param expectedOctetsReceived the number of expected octet to receive
     * @throws Throwable
     */
    public void verifyDumpMemoryTcOctets(MXGSEGSE egse, double wait, String memoryID, String startAddr, String nofOct, String dumpFreq, int expectedOctetsReceived) throws Throwable {
//        System.out.println("  Performing: Large memory dump octet check");
        Hk hke = new Hk();
        //Create the Memory Dump Queue (filter 0x50)
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
                
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Start Address", startAddr);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Nof Octets", nofOct);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Dump Frequency", dumpFreq);
        hkTm.clear();
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("DumpMemoryTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait=wait-0.1;
        }
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump for Memory ID="+memoryID+": "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump for ID "+memoryID+" received", stepResult, stepComment, stepErr);
         
        String[][] MonHK = {
               {"Errors and Warnings", "8",    "0"}
           };
        if(memoryID.equals("1100")) {hke.verifyMonHKarr(egse, 5, MonHK, 2);}
        int queueSizeOld = 0;
        int queueSize = hkTm.size();
        while(queueSizeOld!=queueSize) {
            Thread.sleep(3000);
            queueSizeOld=queueSize;
            queueSize = hkTm.size();
            System.out.println("Memory Dump QueueSize: "+queueSize);
        }
        String dumpData = "";
        String curDumpData;
        while(queueSize > 0) {
            curDumpData = String.valueOf(egse.packetTool.getTmParameter(hkTm.removeFirst(), "Packet Data.Dump Data"));
            curDumpData = curDumpData.substring(3, curDumpData.length()-1);
            dumpData = dumpData + curDumpData;
            queueSize--;
        }
        if ((dumpData.length()/2) != expectedOctetsReceived) {
            stepErr=false;
            stepResult="Failed";
            stepComment="Wrong # of octets";
            System.out.println("Wrong amount of octets received when verifying memory dump: "+ANSI_RED+dumpData.length()/2+ANSI_RESET);
        } else {
            stepErr=true;
            stepResult="OK";
            stepComment="Only size verified";
        }
        output.printStepOut("Dump Data.length()", nofOct, String.valueOf(dumpData.length()/2),stepResult, stepComment, stepErr);
        Thread.sleep(1000);
        String[][] MonHK2 = {
               {"Errors and Warnings", "0",    "0"}
           };
                if(memoryID.equals("1100")) {hke.verifyMonHKarr(egse, 5, MonHK2, 2);}
    }
    
    /**
     * Send DumpMemoryTC and wait (wait) seconds for (noPackets) Non-ScienceTM with dump data.
     * 
     * @param egse
     * @param wait
     * @param memoryID
     * @param startAddr
     * @param nofOct
     * @param dumpFreq
     * @param dumpResult
     * @param noPackets
     * @throws Throwable
     */
    public void verifyLargeDumpMemoryTc(MXGSEGSE egse, double wait, String memoryID, String startAddr, String nofOct, String dumpFreq, String dumpResult, int noPackets) throws Throwable {
//        System.out.println("  Performing: verifyDumpMemoryTc");
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Start Address", startAddr);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Nof Octets", nofOct);
        egse.packetTool.setTcParameter("DumpMemoryTC", "Packet Data.Dump Frequency", dumpFreq);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("DumpMemoryTC"));
        while((hkTm.size() < noPackets) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int stackSize = hkTm.size();
        if (stackSize < 1) {
             stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from verifyLargeDumpMemoryTc (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump for Memory ID="+memoryID+": "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump for ID "+memoryID+" received", stepResult, stepComment, stepErr);
             
        String dumpData = "";
        String curDumpData;
        while(stackSize > 0) {
            curDumpData = String.valueOf(egse.packetTool.getTmParameter(hkTm.removeFirst(), "Packet Data.Dump Data"));
            curDumpData = curDumpData.substring(3, curDumpData.length()-1);
            dumpData = dumpData + curDumpData;
            stackSize--;
        }
        dumpData = "0x[" + dumpData.toUpperCase() + "]";
        if(!dumpResult.equals(dumpData)){
            stepErr=false;
            stepResult="Failed";
            stepComment="";
            System.out.println("  Failed comparing Result. Expected: "+dumpResult+" Received: "+dumpData);
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Dump Memory for Memory ID="+memoryID+": "+ANSI_GREEN+"Correct"+ANSI_RESET);
        }
        output.printStepOut("Dump Data", dumpResult.substring(0, 8)+"..", dumpData.substring(0, 8)+"..",stepResult, stepComment, stepErr);
    }
    
    /**
     * This function is a very specific routine that only applies to step 5.2.11, step 5.3.11 and step 5.4.11.
     * It is created as a function because the test is applied multiple times in the procedure, but with the same variables.
     * @param egse
     * @param result
     * @throws Throwable
     */
    public void verifyAbortMemoryDumpTc(MXGSEGSE egse, int result) throws Throwable {
        double wait=5;
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        egse.packetTool.setTcParameter("AbortDumpMemoryTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", "1");
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("AbortDumpMemoryTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from AbortDumpMemoryTC (Timeout).");
            resultCode = 0;
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if (result != resultCode) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing AbortDumpMemoryTC. Expected: "+result+". Received: "+resultCode);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  AbortDumpMemory: "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    /**
     * This function is a very specific routine that only applies to step 5.2.11, step 5.3.11 and step 5.4.11.
     * It is created as a function because the test is applied multiple times in the procedure, but with the same variables.
     * @param egse
     * @param subSection
     * @throws Throwable
     */
    public void verifyAbortMemoryDumpTcRoutine(MXGSEGSE egse, String subSection) throws Throwable {
        
        Hk hke = new Hk();
        
        System.out.println("  Verify Abort Memory Dump");
        //Create the Memory Dump Queue (filter 0x50):
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        int numberOfOctets = 32768;

        
//        System.out.println("  Performing: Dump Data verify");
        output.printStepStart(subSection+"-1", "Dump Memory", "Memory ID = 1000");
        sendDumpMemoryTc(egse, "1000", "0", String.valueOf(numberOfOctets), "7");
        double wait = 5;
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump for Memory ID=1000: "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump for ID 1000 received", stepResult, stepComment, stepErr);
        
        String[][] MonHK = {
               {"Errors and Warnings", "8",    "0"}
           };
        hke.verifyMonHKarr(egse, 5, MonHK, 2);
        
        //verify dump data is correct.
        output.printStepStart(subSection+"-2", "Verify dumped data");
        int queueSizeOld = 0;
        int queueSize = hkTm.size();
        while(queueSizeOld!=queueSize) {
            Thread.sleep(3000);
            queueSizeOld=queueSize;
            queueSize = hkTm.size();
            System.out.println("Memory Dump QueueSize: "+queueSize);
        }
        String dumpData = "";
        String curDumpData;
        while(queueSize > 0) {
            curDumpData = String.valueOf(egse.packetTool.getTmParameter(hkTm.removeFirst(), "Packet Data.Dump Data"));
            curDumpData = curDumpData.substring(3, curDumpData.length()-1);
            dumpData = dumpData + curDumpData;
            queueSize--;
        }
        if ((dumpData.length()/2) != numberOfOctets) {
            stepErr=false;
            stepResult="Failed";
            stepComment="";
            System.out.println("Wrong amount of octets received when verifying large memory dump");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  DumpData size "+ANSI_GREEN+"OK"+ANSI_RESET);
        }
        output.printStepOut("DumpData size", numberOfOctets, dumpData.length()/2, stepResult, stepComment, stepErr);
        Thread.sleep(2000);
        String[][] MonHK2 = {
               {"Errors and Warnings", "0",    "0"}
           };
        hke.verifyMonHKarr(egse, 5, MonHK2, 2);

        //Verify the abort dump
//        System.out.println("  Performing: Abort Memory Dump verify");
        //Clear queue, and create a command verification report queue:
        output.printStepStart(subSection+"-3", "Dump Memory", "Memory ID = 1000");
        hkTm.clear();
        ParameterValueEvent hkEventCVR = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTmCVR = new ParameterValueFilter(hkEventCVR, Logger.global);
        //Send DumpMemoryTC
        wait=10.0;
        egse.packetTool.setTcParameter("AbortDumpMemoryTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", "1");
        sendDumpMemoryTc(egse, "1000", "0", String.valueOf(numberOfOctets), "7");
         while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println("No response received from DumpMemoryTC (Timeout).");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump for Memory ID=1000: "+ANSI_GREEN+"Received"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump for ID 1000 received", stepResult, stepComment, stepErr);
        //Send abort dump:
        egse.packetTool.setTcParameter("AbortDumpMemoryTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", "0");
        output.printStepStart(subSection+"-4", "Abort Dump Memory", "Memory ID = 1000");
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("AbortDumpMemoryTC"));
        
        //Verify number of octets received:
        queueSizeOld = 0;
        queueSize = hkTm.size();
        while(queueSizeOld!=queueSize) {
            Thread.sleep(5000);
            queueSizeOld=queueSize;
            queueSize = hkTm.size();
            System.out.println("Memory Dump QueueSize: "+queueSize);
        }
        dumpData = "";
        while(queueSize > 0) {
            curDumpData = String.valueOf(egse.packetTool.getTmParameter(hkTm.removeFirst(), "Packet Data.Dump Data"));
            curDumpData = curDumpData.substring(3, curDumpData.length()-1);
            dumpData = dumpData + curDumpData;
            queueSize--;
        }
        if ((dumpData.length()/2) == numberOfOctets) {
            stepErr=false;
            stepResult="Failed";
            stepComment="All Octets received";
            System.out.println("Memory dump was not aborted - all octets received from dump.");
        }
        else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
            System.out.println("  Memory dump aborted: "+ANSI_GREEN+"OK"+ANSI_RESET);
        }
        output.printStepOut("Memory Dump aborted", stepResult, stepComment, stepErr);

        //verify Command verification Report:
        Thread.sleep(2000);
        if(hkTmCVR.size()==0) {
            stepErr=false;
            stepResult="Failed";
            stepComment="Report not received";
            System.out.println("Command Verification Report"+ANSI_RED+"not received"+ANSI_RESET);
        } else{
            int cvrResult = Integer.valueOf(egse.packetTool.getTmParameter(hkTmCVR.removeLast(), "Packet Data.Result"));
            if (cvrResult != 30030) {
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Incorrect result code: "+ANSI_RED+cvrResult+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Result: "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
            output.printStepOut("Result", 30030, cvrResult, stepResult, stepComment, stepErr);
            hke.verifyMonHKarr(egse, 5, MonHK2, 2);
        }
    }
    
    
    /**
     *
     * @param egse
     * @param wait
     * @param memoryID
     * @param startAddr
     * @param nofOct
     * @param dumpFreq
     * @throws Throwable
     * @return dumpData
     */
    public String verifyDumpMemoryTc(MXGSEGSE egse, double wait, String memoryID, String startAddr, String nofOct, String dumpFreq) throws Throwable {
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x50), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        hkTm.clear();
        sendDumpMemoryTc(egse, memoryID, startAddr, nofOct, dumpFreq);
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int queueSizeOld = 0;
        int queueSize = hkTm.size();
        
        String dumpData = "";
        String curDumpData;
        double timeout=0;
        while((dumpData.length()/2) != Long.valueOf(nofOct) & timeout < 3) {
            timeout+=0.200;
            queueSize = hkTm.size();
            if(queueSize>0){
                while(queueSize > 0) {
                    curDumpData = egse.packetTool.getTmParameter(hkTm.removeFirst(), "Packet Data.Dump Data");
                    curDumpData = curDumpData.substring(3, curDumpData.length()-1);
                    dumpData = dumpData + curDumpData;
                    queueSize--;
                }
                timeout=0;
            }
            Thread.sleep(200);
        }
        
        if ((dumpData.length()/2) != Long.valueOf(nofOct)) {
            stepErr=false;
            stepResult="Failed";
            stepComment="Wrong # of octets";
            System.out.println("Wrong amount of octets received when verifying memory dump: "+ANSI_RED+dumpData.length()+ANSI_RESET);
        } else {
            stepErr=true;
            stepResult="OK";
            stepComment="";
        }
        output.printStepOut("Dump Data.length()", nofOct, String.valueOf(dumpData.length()/2),stepResult, stepComment, stepErr);
        return dumpData;
    }
    
    
    /**
     *
     * @param egse
     * @param wait
     * @param result
     * @throws Throwable
     */
    public void verifyPrepareShutdownTc(MXGSEGSE egse, double wait, int result) throws Throwable {
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("PrepareShutdownTC"));
        //Wait for Non science respone. Max wait time 30 seconds.
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode = 0;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println(ANSI_RED+"No response received from PrepareShutdownTC (Timeout)."+ANSI_RESET);
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if(result != resultCode){
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing Result. "+ANSI_RED+"Expected: "+result+". Recieved: "+resultCode+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Prepare Shutdown: "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    /**
     *
     * @param egse
     * @param wait
     * @param memoryID
     * @param NVMload
     * @param acknowledgeSuccessCompl  * @param result
     * @param result
     * @throws Throwable
     */
    public void verifyLoadConfigurationParameters(MXGSEGSE egse, double wait, String memoryID, String NVMload, String acknowledgeSuccessCompl, int result) throws Throwable {
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        egse.packetTool.setTcParameter("LoadConfigurationParametersTC", "Packet Data.Memory ID", memoryID);
        egse.packetTool.setTcParameter("LoadConfigurationParametersTC", "Packet Data.NVM Load", NVMload);
        egse.packetTool.setTcParameter("LoadConfigurationParametersTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", acknowledgeSuccessCompl);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("LoadConfigurationParametersTC"));

        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode = 0;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println(ANSI_RED+"No response received from LoadConfigurationParametersTC (Timeout)."+ANSI_RESET);
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if(result != resultCode){
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing Result. "+ANSI_RED+"Expected: "+result+". Recieved: "+resultCode+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  Load Configuration Parameters for Memory ID="+memoryID+": "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    /**
     *
     * @param egse
     * @param wait
     * @param result
     * @throws Throwable
     */
    public void verifyGenerateCrossTriggerTc(MXGSEGSE egse, double wait, int result) throws Throwable {
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        
        egse.packetTool.setTcParameter("GenerateCrossTriggerTC", "Private Header.Packet Identification.Class.Acknowledge Successful Completion", "1");
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("GenerateCrossTriggerTC"));
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode = 0;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println(ANSI_RED+"No response received from GenerateCrossTriggerTC (Timeout)."+ANSI_RESET);
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if(result != resultCode){
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing Result. "+ANSI_RED+"Expected: "+result+". Recieved: "+resultCode+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  GenerateCrossTrigger: "+ANSI_GREEN+"OK"+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    public void sendGenerateCrossTriggerTc(MXGSEGSE egse) throws Throwable {
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("GenerateCrossTriggerTC"));
    }
    
    /**
     * Send EnterScienceSubmodeTC and verifies the expected (result).
     * @param egse
     * @param wait  maximum wait time
     * @param swSubmode SW Sub mode
     * @param result    expected result
     * @throws Throwable
     * @author stet 
     */
    public void verifyEnterScienceSubmodeTc(MXGSEGSE egse, double wait, String swSubmode, int result) throws Throwable {
        ParameterValueEvent hkEvent = new ParameterValueEvent(egse.dhpu.getNonscienceTm(), egse.packetTool, "Private Header.Packet Identification.TM Type", String.valueOf(0x10), Logger.global);
        ParameterValueFilter hkTm = new ParameterValueFilter(hkEvent, Logger.global);
        hkTm.clear();
        egse.packetTool.setTcParameter("EnterScienceSubmodeTC", "Packet Data.SW Submode", swSubmode);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnterScienceSubmodeTC"));
        
        while((hkTm.size() < 1) && (wait > 0)) {
            Thread.sleep(100);
            wait = wait - 0.1;
        }
        int resultCode = 0;
        if(wait <= 0){
            stepErr=false;
            stepResult="Failed";
            stepComment="No response (Timeout)";
            System.out.println(ANSI_RED+"No response received from EnterScienceSubmodeTC (Timeout)."+ANSI_RESET);
        }
        else {
            resultCode = Integer.valueOf(egse.packetTool.getTmParameter(hkTm.removeLast(), "Packet Data.Result"));
            if(result != resultCode){
                stepErr=false;
                stepResult="Failed";
                stepComment="";
                System.out.println("Failed comparing Result. "+ANSI_RED+"Expected: "+result+". Recieved: "+resultCode+ANSI_RESET);
            }
            else {
                stepErr=true;
                stepResult="OK";
                stepComment="";
                System.out.println("  EnterScienceSubmode: "+ANSI_GREEN+resultCode+ANSI_RESET);
            }
        }
        output.printStepOut("Result", result, resultCode, stepResult, stepComment, stepErr);
    }
    
    public void sendEnterScienceSubmodeTc(MXGSEGSE egse, String swSubmode) throws Throwable {
        egse.packetTool.setTcParameter("EnterScienceSubmodeTC", "Packet Data.SW Submode", swSubmode);
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("EnterScienceSubmodeTC"));
    }
    
    public void sendPrepareShutdownTc(MXGSEGSE egse) throws Throwable{
        egse.dhpu.sendNormalTc(egse.packetTool.getTc("PrepareShutdownTC"));
    }
    
}