Table of Contents
Previous Chapter
Table of Contents
Previous Chapter
The purpose of the command handler classes are to interpret the contents of received command packets and execute the operations mandated by the command packet operation code. This section describes the command handler class design. The details of the command packet formats are shown in the "ACIS Instrument Program and Command List," MIT 36-01410 (IP&CL).
The commands used during boot to load an image from uplink and execute the loaded image are not described in this section. Refer to the IP&CL for a description of these particular command formats and their scenarios. NOTE: Command handlers cannot assume that unused bits within command packet words are zero, and shall mask off bits within words that they do not use.
All command handlers are a subclass of Protocols::CmdHandler (see Section 16.0). Each subclass of CmdHandler implements its own processCmd() member function. Given the large number of command handler classes, the following figures illustrate the class relationships involved in each of the use-cases listed above.
FIGURE 63. Parameter Block Command Handler Classes
ChLoadBlk- This class is a subclass of CmdHandler and represents all command handlers which load either Science or DEA parameter blocks into the instrument. The constructor for this handler class requires a command opcode and a reference to a parameter block list (PblockList). The constructed instance associated with the opcode is then responsible for loading parameter blocks from incoming commands into its parameter block list. This class uses the PblockList class to store the loaded parameter block. The ChLoadBlk class has knowledge about the common header format all parameter blocks, but leaves the interpretation of the body of the parameter block up to the specific parameter block type maintained by the targeted parameter block list.
PblockList- This class is responsible for providing the top-level interface to all types of parameter blocks within the instrument. The top level functions provided by this class are used by the command handler class to install parameter blocks, and by Science and DEA Housekeeping to retrieve loaded parameter blocks. This class is described in detail in Section TBD.
FIGURE 64. Memory Server Command Handler Classes
ChReadBep- This is a subclass of CmdHandler and is responsible for handling commands to read and telemeter data and/or code from the Back End Processor's RAM. This class uses the MemoryServer class to perform the actual operation.
ChWriteBep- This is a subclass of CmdHandler and is responsible for handling commands to write data (and possibly code) to the Back End Processor's RAM. This class uses the MemoryServer class to perform the actual operation.
ChExecBep- This is a subclass of CmdHandler and is responsible for handling commands instructing the instrument to call a subroutine located within the Back End Processor's RAM. This class uses the MemoryServer class to perform the actual operation.
ChReadFep- This is a subclass of CmdHandler and is responsible for handling commands to read and telemeter data (and possibly code) from one of the Front End Processors' RAM. This class uses the MemoryServer class to perform the actual operation.
ChWriteFep- This is a subclass of CmdHandler and is responsible for handling commands to write data (and possibly code) to one of the Front End Processors' RAM. This class uses the MemoryServer class to perform the actual operation.
ChExecFep- This is a subclass of CmdHandler and is responsible for handling commands instructing the instrument to call a subroutine located within one of the Front End Processors' RAM. This class uses the MemoryServer class to perform the actual operation.
ChReadPram- This is a subclass of CmdHandler and is responsible for handling commands to read and telemeter data from one of the Detector Electronics Assembly (DEA) CCD Controller's Program RAM (PRAM). This class uses the MemoryServer class to perform the actual operation.
ChWritePram- This is a subclass of CmdHandler and is responsible for handling commands to write data to one of the DEA CCD Controller's Program RAM. This class uses the MemoryServer class to perform the actual operation.
ChReadSram- This is a subclass of CmdHandler and is responsible for handling commands to read and telemeter data from one of the DEA CCD Controller's Sequencer RAM (SRAM). This class uses the MemoryServer class to perform the actual operation.
ChWriteSram- This is a subclass of CmdHandler and is responsible for handling commands to write data to one of the DEA CCD Controller's Sequencer RAM. This class uses the MemoryServer class to perform the actual operation.
MemoryServer- This class is a subclass of Executive::Task (not shown), and is responsible for performing or initiating all memory loads, dumps and executes within ACIS. This class is described in detail in Section 27.0.
FIGURE 65. Science Run and DEA Housekeeping Command Handler Classes
ChStartSciRun- This class is a subclass of CmdHandler, and is responsible for handling commands initiating a science run. Upon construction, each instance of this class is passed a command opcode, a reference to a ScienceMode instance, and a flag indicating whether or not the command requests only a bias computation, with no subsequent data processing. Once a command is received, the handler instance associated with the command's opcode uses installed ScienceMode and bias-only flag to instruct the ScienceManager what type of science run was requested.
ChStopSciRun- This class is a subclass of CmdHandler, and is responsible for terminating an active science run. There is one instance of this class for each type of science run. This class uses the ScienceManager to terminate the run. NOTE: If a science command is running, but the stop request is of the wrong type or specifies the wrong parameter block slot id, the current run will be stopped anyway, and a software housekeeping error statistic will be reported. When a run is stopped, it finishes its current exposure. The run's telemetry packets remain in the telemetry queue until they are sent out of the instrument by the telemetry manager.
ChStartDeaRun- This class is a subclass of CmdHandler, and is responsible for handling commands that initiate acquisition of DEA Housekeeping data. This class uses the DeaHousekeeper to perform the operation.
ChStopDeaRun- This class is a subclass of CmdHandler, and is responsible for handling commands that request the termination of DEA housekeeping acquisition. This class uses the DeaHousekeeper class to terminate the operation. NOTE: If the stop request specifies the wrong parameter block slot id, the current run will be stopped anyway, and a software housekeeping error statistic will be reported. When a run is stopped, it finishes its current housekeeping packet. The run's telemetry packets remain in the telemetry queue until they are sent out of the instrument by the telemetry manager.
ScienceManager- This class is a subclass of Executive::Task (not shown).This class is responsible for coordinating science bias computations and data runs. See Section 33.0 for a more detailed description of this class.
ScienceMode- This class is responsible for implementing the detailed setup, parameter dump, bias computation, data processing, and cleanup operations of a particular science mode. This class operates under the direction of the ScienceManager class. This class is described in more detail in Section 33.0.
DeaHousekeeper- This class is a subclass of Executive::Task (not shown), and is responsible for periodically acquiring and telemetering DEA housekeeping information. This class is described in more detail in Section TBD.
FIGURE 66. Patch Command Handler Classes
ChAddPatch- This class is a subclass of CmdHandler and is responsible for handling commands which install new patches into the ACIS patch list. This class uses the PatchList class to add the requested patch to the system. The installed patch will not take effect until the next commanded reset.
ChRemovePatch- This class is a subclass of CmdHandler and is responsible for removing a patch from the ACIS software patch list. This class uses the PatchList class to remove the patch from the system. The code or data affected by the removed patch will not be restored until the next commanded reset.
PatchList- This class is responsible for maintaining the ACIS software patch list. It is described in more detail in Section TBD.
FIGURE 67. System Configuration Command Handler Classes
Within ACIS, there is one bad pixel map, for use with Timed Exposure Mode, and two bad column maps, one for Timed Exposure Mode, and one for use with Continuous Clocking Mode.
ChAddBadPixel- This class is a subclass of CmdHandler and is responsible for handling commands which install one or more bad pixels in the system's bad pixel list. This class uses the BadPixelMap class to maintain the current list of bad pixels.
ChRemoveBadPixel- This class is a subclass of CmdHandler, and is responsible for handling commands which remove pixels from the system's bad pixel list, or which clear the entire list. This class uses the BadPixelMap class to maintain the current list of bad pixels.
ChDumpBadPixels- This class is a subclass of CmdHandler, and is responsible for dumping the contents of the bad pixel map to telemetry. This class uses the BadPixelMap class to obtain access to the address and current length of the bad pixel map buffer. This class then uses the MemoryServer class to iteratively format and send memory dump packets of the bad pixel map.
ChAddBadCol- This class is a subclass of CmdHandler, and is responsible for adding one or more bad columns to a bad column map. Upon construction, each instance of this handler is associated with a command opcode and a BadColumnMap instance. Each handler instance uses its associated BadColumnMap instance to maintain the list of bad columns.
ChRemoveBadCol- This class is a subclass of CmdHandler, and is responsible for removing one or more bad columns from a bad column map, or clear all bad columns from the corresponding map. Upon construction, each instance of this handler is associated with a command opcode and a BadColumnMap instance. Each handler instance uses its associated BadColumnMap instance to maintain the list of bad columns.
ChDumpBadCol- This class is a subclass of CmdHandler, and is responsible for dumping the contents of the bad pixel map to telemetry. Upon construction, each instance of this handler is associated with a command opcode and a BadColumnMap instance. Each handler instance uses its associated BadColumnMap instance to obtain the address and current length of a given bad column map. The handler uses the MemoryServer class to iteratively format and dump the contents of the map to telemetry.
ChChangeSysEntry- This class is a subclass of CmdHandler, and is responsible for handling commands which change one or more values of the System Configuration Table. This class uses the SysConfigTable class to maintain the current system settings.
ChDumpSysConfig- This class is a subclass of CmdHandler, and is responsible for handling commands which request a dump of the current System Configuration Table entries. The handler class uses the SysConfigTable class to obtain the address and length of the table, and uses the MemoryServer to format and dump the table to telemetry.
All command packet header information is accessed via the CmdPkt class (see Section 16.0). Unless otherwise specified, all command handler processCmd() member functions are required to execute in under 200ms. If a command takes longer than 200ms to execute, the handler should consider forwarding the request onto a lower priority task to execute.
In order to make interpretation of command packets easier, all packets must align long word data elements on long word boundaries. All command packet buffers will start on a long word boundary, and the command packet header will always be an odd number of 16-bit words in length.
See Section 4.6 for a detailed description of all command packet formats defined by ACIS.
The following table maps each command packet type to a specific object name and class.
TABLE 20. Command Packet to Handler Object Map
------------------------------------------------------------------------------------------------ Command Opcode Symbol Object Name Class Name------------------------------------------------------------------------------------------------ Load Timed Exposure Parameter Block CMDOP_LOAD_TE chLoadTimedExp ChLoadBlk Load Cont. Clocking Parameter Block CMDOP_LOAD_CC chLoadContClock ChLoadBlk Load 2-D Window List CMDOP_LOAD_2D chLoad2dWindow ChLoadBlk Load 1-D Window List CMDOP_LOAD_1D chLoad1dWindow ChLoadBlk Load DEA House.Parameter Block CMDOP_LOAD_DEA chLoadDeaHouse ChLoadBlk Read BEP Memory CMDOP_READ_BEP chReadBep ChReadBep Write BEP Memory CMDOP_WRITE_BEP chWriteBep ChWriteBep Execute BEP Memory CMDOP_EXEC_BEP chExecBep ChExecBep Read FEP Memory CMDOP_READ_FEP chReadFep ChReadFep Write FEP Memory CMDOP_WRITE_FEP chWriteFep ChWriteFep Execute FEP Memory CMDOP_EXEC_FEP chExecFep ChExecFep Read PRAM CMDOP_READ_PRAM chReadPram ChReadPram Write PRAM CMDOP_WRITE_PRAM chWritePram ChWritePram Read SRAM CMDOP_READ_SRAM chReadSram ChReadSram Write SRAM CMDOP_WRITE_SRAM chWriteSram ChWriteSram Start Timed Exposure CMDOP_START_TE chStartTimedExp ChStartSciRun Start Timed Exposure Bias Only CMDOP_BIAS_TE chBiasTimedExp ChStartSciRun Stop Timed Exposure CMDOP_STOP_TE chStopTimedExp ChStopSciRun Start Continuous Clocking CMDOP_START_CC chStartCc ChStartSciRun Start Continuous Clocking Bias Only CMDOP_BIAS_CC chBiasCc ChStartSciRun Stop Continuous Clocking CMDOP_STOP_CC chStopCc ChStopSciRun Start DEA Housekeeping CMDOP_START_DEA chStartDeaRun ChStartDeaRun Stop DEA Housekeeping CMDOP_STOP_DEA chStopDeaRun ChStopDeaRun Add Patch CMDOP_ADD_PATCH chAddPatch ChAddPatch Remove Patch CMDOP_REMOVE_PATCH chRemovePatch ChRemovePatch Add Bad Pixel CMDOP_ADD_BAD_PIXEL chAddBadPixel ChAddBadPixel Remove Bad Pixel CMDOP_REMOVE_BAD_PIXEL chRemoveBadPixel ChRemoveBadPixel Dump Bad Pixels CMDOP_DUMP_BAD_PIXELS chDumpBadPixels ChDumpBadPixels Add Bad Timed Exposure Column CMDOP_ADD_BAD_TE_COL chAddBadTeCol ChAddBadCol Remove Bad Timed Exposure Column CMDOP_REMOVE_BAD_TE_COL chRemoveBadTeCol ChRemoveBadCol Dump Bad Timed Exposure Columns CMDOP_DUMP_BAD_TE_COL chDumpBadTeCol ChDumpBadCol Add Bad Continuous Clocking Column CMDOP_ADD_BAD_CC_COL chAddBadCcCol ChAddBadCol Remove Bad Cont. Clocking Column CMDOP_REMOVE_BAD_CC_COL chRemoveBadCcCol ChRemoveBadCol Dump Bad Cont. Clocking Columns CMDOP_DUMP_BAD_CC_COL chDumpBadCcCol ChDumpBadCol Change System Configuration Entry CMDOP_CHANGE_SYS_ENTRY chChangeSysEntry ChChangeSysEntry Dump System Configuration Entries CMDOP_DUMP_SYS_CONFIG chDumpSysConfig ChDumpSysConfig ------------------------------------------------------------------------------------------------
Each of the command handler objects are created during system initialization, and are registered with the Command Manager at that time. Figure 68 illustrates the overall initialization procedure used to construct command handlers which store parameter blocks within ACIS. The following scenario details the actions taken when constructing the "Load Timed Exposure Parameter Block" command handler. The scenario applies to all of the remaining constructors, by varying only the command operation codes and parameter block list references for each distinct command handler object.
FIGURE 68. Parameter Block Command Handler Initialization
Figure 69 illustrates the overall execution of a "Load Timed Exposure Parameter Block Command." Other types of "Load Parameter Block" commands operate in the same fashion, only using different command handler instances and destination parameter block lists.
FIGURE 69. Load Timed Exposure Parameter Block Command Execution
Figure 70 illustrates the behaviors of the three commands directed toward the MemoryServer. Steps 1 - 5 illustrate the overall scenario for a "Read BEP Memory" command, from the point at which the cmdManager dispatches control of the chReadBep command handler instance, to the point at which the MemoryServer dispatches control to its private function, rdBep() to actually perform the memory read (NOTE: In order to clarify the overall behavior of the command handlers in association with the MemoryServer, this example violates strict encapsulation rules, and peeks a little bit into the internal implementation of the MemoryServer). The remaining objects in the diagram are not described step-by-step, but the overall behavior of each of the command handlers is the same at that for the "Read BEP Memory" example. They are shown in the diagram to illustrate the mapping each command handler instance to the corresponding binding function provided by the MemoryServer.
FIGURE 70. Memory Server Command Handling
Different types of "Start Science Run" and "Stop Science Run" command handlers are discriminated only by their command operation code and parameter block list reference. Figure 71 illustrates the overall initialization procedure used to construct command handlers which start and stop science runs within ACIS. The scenario description details the actions taken when constructing the "Start Timed Exposure Run" command handler. The scenario applies all of the remaining constructors, by varying only the command operation codes and science mode references for each distinct command handler object. Since "Start DEA Housekeeping Run" and "Stop DEA Housekeeping Run" command handlers each have only one instance, their construction is shown in the diagram, but is not directly explained in the accompanying scenario description.
FIGURE 71. Start and Stop Run Command Handler Initialization
Figure 72 illustrates the overall operation of a "Start Timed Exposure" and "Stop Timed Exposure" command sequence. The scenario for starting and stopping a Continuous Clocking Run is the same except the chStartTimedExp, smTimedExp, and pblTimedExp objects are replaced with the chStartCc, smContClocking, and pblContClock objects, respectively.
FIGURE 72. Start and Stop Timed Exposure Science Run
Figure 73 illustrates the behavior of a Start and Stop DEA Run command sequence. The scenario is similar to that for science runs, except that the scenario invokes the DeaHousekeeper and that the housekeeper is responsible for interacting with the DEA Housekeeping Parameter Block List.
FIGURE 73. Start and Stop DEA Housekeeping
Figure 74 illustrates the handling of "Add Patch" and "Remove Patch" commands.
FIGURE 74. Add and Remove Patch Command Handling
Figure 75 illustrates the operations used to add, remove and dump bad pixels within ACIS. The illustration also shows how the system configuration settings are modified and dumped, but this is not described in the detailed scenario description. Not shown are the operations to add, remove and dump bad columns from either the Timed Exposure Bad Column Map, nor the Continuous Clocking Bad Column Map. The overall sequences for these two maps are the same as the sequence from Bad Pixels, just with different objects participating. Not shown is that the Timed Exposure and Continuous Clocking Bad Column map commands use different instances of the same class, which are discriminated during construction by a passed command opcode and a reference to their respective Bad Column Maps.
NOTE: Since some structures, including the bad pixel map, may be larger than will fit into a single telemetry packet, a design decision has been made to use the MemoryServer to dump the system configuration data structures. The effect is that the information will reach the ground without specific format information contained with the telemetry packet. It is assumed that the ground can use the dump address and memory map, or can use the command packet identifier to determine what was dumped and why.
FIGURE 75. System Configuration Command Handling
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
BadColumnMap
Public Interface:
Operations:
ChAddBadCol() processCmd()
Private Interface:
Has-A Relationships:
Arguments:
CmdOpcode opcode
BadColumnMap& badColMap
Documentation:
This constructor initializes an instance of this class, passing opcode to its parent CmdHandler() constructor, which associates the instance with the particular opcode, and initializing its bad column map to the passed badColMap.
Arguments:
const CmdPkt* pkt
Documentation:
This function adds bad columns to the instance's bad column map, map. pkt points to the command packet containing the columns to add to the list. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_TABLE_FULL
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
BadPixelMap
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function handles requests to add pixels to the bad pixel map. pkt points to the command packet containing the pixels to add to the list. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_TABLE_FULL
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
PatchList
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function handles commands to add patches to the system patch list. pkt is a pointer to the command packet containing the patch to add. This function returns one of the following:
CMDRESULT_OK CMDRESULT_TABLE_FULL
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
SysConfigTable
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function handles commands which modify system configuration entry values. pkt points to the requesting command packet, and contains the entry modifications. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
BadColumnMap
Public Interface:
Operations:
ChDumpBadCol() processCmd()
Private Interface:
Has-A Relationships:
Arguments:
CmdOpcode opcode
BadColumnMap& badColMap
Documentation:
This constructor initializes an instance of this class, passing opcode to its parent CmdHandler() constructor, which associates the instance with the particular opcode, and initializing its bad column map to the passed badColMap.
Arguments:
const CmdPkt* pkt
Documentation:
This function initiates a dump of the contents of the instance's bad column map. pkt is a pointer to the command packet requesting the dump, and is not used by this function. This function relies on the MemoryServer to perform the actual dump. This function returns one of the following:
CMDRESULT_OK CMDRESULT_TABLE_EMPTY CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
BadPixelMap
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function initiates a dump of the bad pixel map to telemetry. pkt is a pointer to the command packet requesting the dump, and is not used by this function. This function relies on the MemoryServer to perform the actual dump. This function returns one of the following:
CMDRESULT_OK CMDRESULT_TABLE_EMPTY CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
SysConfigTable
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function handles commands which request a dump of the system configuration entries to telemetry. pkt points to the command packet making the request, but is unused by this function. This function relies on the MemoryServer to perform the actual dump. This function returns one of the following:
CMDRESULT_OK CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's executeBep() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's executeFep() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Public Interface:
Operations:
ChLoadBlk() processCmd()
Private Interface:
Has-A Relationships:
Arguments:
CmdOpcode opcode
PblockList& blocklist
Documentation:
This is the constructor for all Load Parameter Block command handlers. opcode specifies the command packet opcode used for the command, and blocklist is a reference to the parameter block list modified by the handler.
Arguments:
const CmdPkt* cmdpkt
Documentation:
This function processes all "load parameter block" commands, installing the parameter block contained in cmdpkt. If the load is successful, this function returns CMDRESULT_OK. If the command cannot obtain access to the parameter block, it returns CMDRESULT_BUSY. If the parameter block contained within the command has been corrupted, it returns CMDRESULT_CORRUPT.
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's readBep() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's readFep() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's readPram() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's readSram() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
BadColumnMap
Public Interface:
Operations:
ChRemoveBadCol() processCmd()
Private Interface:
Has-A Relationships:
Arguments:
CmdOpcode opcode
BadColumnMap& badColMap
Documentation:
This constructor initializes the handler instance, passing opcode to the parent constructor CmdHandler() which associates the instance with the command, and initializing map with the passed badColMap argument.
Arguments:
const CmdPkt* pkt
Documentation:
This function removes pixels from the bad column map managed by this instance, map. pkt is the command packet containing a list of columns to remove. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
BadPixelMap
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function removes pixels from the system's bad pixel map. pkt is the command packet containing a list of pixels to remove. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
PatchList
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function removes patches from the system patch list. pkt points to the command packet containing the patch identifiers to be removed. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATAPTR CMDRESULT_INVALID_DATACNT CMDRESULT_BAD_ARGUMENT
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
DeaHousekeeper
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function processes requests to start a DEA Housekeeping run. cmdpkt points to the requesting command packet, and contains the block id to use for the run. This function returns one of the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_CORRUPT_DEFAULT CMDRESULT_CORRUPT_IDLE
Hierarchy:
Superclasses:
CmdHandler
Public Uses:
ScienceMode
Implementation Uses:
ScienceManager
Public Interface:
Operations:
ChStartSciRun() processCmd()
Private Interface:
Has-A Relationships:
Arguments:
CmdOpcode opcode
ScienceMode& mode
Boolean biasOnly
Documentation:
This is the constructor for a science run command handler. opcode is the command operation handled by the instance being constructed, scienceMode is a reference to the science mode started by this handler, and biasOnly is a flag indicating if this command is handling compute bias requests (rather than full science runs). If biasOnly is BoolFalse, the handler will initiate complete science runs. If biasOnly is BoolTrue, then the handler will initiate bias computations only.
Arguments:
CmdPkt* cmdpkt
Documentation:
This function handles commands which initiate science runs. cmdpkt is a pointer to the requesting command packet, and contains the parameter block id to use for the science run. This function returns one of the following:
CMDRESULT_OK CMDRESULT_BAD_DATACNT CMDRESULT_BAD_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_CORRUPT_DEFAULT CMDRESULT_CORRUPT_IDLE
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
DeaHousekeeper
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function processes requests to stop a DEA housekeeping run. pkt points to the requesting command packet. This function checks the passed command, reports discrepencies to software housekeeping, and then stops the run. This function always returns CMDRESULT_OK.
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
ScienceManager
Public Interface:
Operations:
ChStopSciRun() processCmd()
Arguments:
CmdOpcode opcode
Documentation:
This constructor initializes the state of the handler instance, and using its parents constructor, CmdHandler(), associates the instance with the command opcode used to terminate a particular science mode.
Arguments:
const CmdPkt* cmdpkt
Documentation:
This function handles requests to stop a running science mode. cmdpkt points to the requesting command packet. This function checks the contents of cmdpkt with the current science state, reports discrepencies to software housekeeping, and stops the run. This function always returns CMDRESULT_OK.
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's writeBep() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's writeFep() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's writePram() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Hierarchy:
Superclasses:
CmdHandler
Implementation Uses:
MemoryServer
Public Interface:
Operations:
processCmd()
Arguments:
const CmdPkt* pkt
Documentation:
This function interprets the contents of the command packet, pkt, and passes the extracted parameters to the MemoryServer's writeSram() binding function. This function returns the following:
CMDRESULT_OK CMDRESULT_INVALID_DATACNT CMDRESULT_INVALID_DATAPTR CMDRESULT_BAD_ARGUMENT CMDRESULT_BUSY
Next Chapter