/************************************************************************* $Archive: /PACS/OnBoard/RDecCtrl.c $ $Revision: 1.11 $ $Date: 2009/04/23 13:51:12 $ $Author: amazy $ $Log: RDecCtrl.c,v $ Revision 1.11 2009/04/23 13:51:12 amazy 6.029 * * 51 3/14/06 4:32p Pacs Egse * Version 6.001 * Cleaned and commented *************************************************************************/ #ifdef SIMULATOR #include "virtuosoSim.h" #else // SIMULATOR #include "v_macro.h" #include "node1.h" #include "k_struct.h" #endif #include "seq_msg.h" #include "params.h" #include "links.h" #include "error.h" #include "det.h" #include "u_res.h" #include "m_smcsin.h" #include "m_smcsco.h" //**************************************************************** // MACRO //**************************************************************** //macro to signal an error in Red Dec Controller Task #define SetError(newError) \ {\ SetGlobalError(newError);\ LOCK_WRITE_RES_PARAMS;\ SET_BITS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_ERROR_STATUS | K_BMASK_TASK_STATUS_ERROR_CODE, K_BMASK_TASK_STATUS_TASK_IN_ERROR + newError); \ UNLOCK_WRITE_RES_PARAMS;\ }\ /* MACRO : LINK_1355_WRITE *********************** AUTHOR : AMazy USE : When we use a detector simulator with simulated timing, the detector is inactive so the dec controller can not write commands on the link 1355. */ #define LINK_1355_WRITE(a, b, c) \ LOCK_READ_RES_PARAMS;\ if (IS(gpRedDecRec->TaskStatus, K_BMASK_SIMULATION_TIMING, K_BMASK_REAL_TIMING)) \ {\ UNLOCK_READ_RES_PARAMS;\ Link1355Write(a, b, c); \ gpRedDecController->PacketCounter++; \ }\ else\ {\ UNLOCK_READ_RES_PARAMS;\ } //**************************************************************** // FUNCTION DECLARATION //**************************************************************** void InitializeRedDecCtrl(); void RedDecCtrl(); // commands functions BOOL CommandSwitchOnRedDEC(CommandParameter paramNotUsed); BOOL CommandSwitchOffRedDEC(CommandParameter paramNotUsed); BOOL CommandSwitchOnRedSpectroArray(CommandParameter paramNotUsed); BOOL CommandSwitchOffRedSpectroArray(CommandParameter paramNotUsed); BOOL CommandValidateScienceDataRed(CommandParameter paramNotUsed); BOOL CommandInvalidateScienceDataRed(CommandParameter paramNotUsed); BOOL CommandSetRedSpectroHeaterCurrent(CommandParameter param); BOOL CommandSetRedSpectroFlasherCurrent(CommandParameter param); BOOL CommandSwOnRedHeater(CommandParameter paramNotUsed); BOOL CommandSwOffRedHeater(CommandParameter paramNotUsed); BOOL CommandSwOnRedFlasher(CommandParameter paramNotUsed); BOOL CommandSwOffRedFlasher(CommandParameter paramNotUsed); //**************************************************************** // FUNCTION IMPLEMENTATION //**************************************************************** /* FUNCTION : void InitializeRedDecCtrl() ************************************** AUTHOR : AMazy USE : Initialize Dec Controller task. */ void InitializeRedDecCtrl() { LOCK_WRITE_RES_PARAMS; // initialize status gpRedDecController->TaskStatus = K_BMASK_TASK_STATUS_ALIVE | K_BMASK_TASK_STATUS_NO_ERROR_IN_TASK | K_BMASK_TASK_STATUS_LINK_NOT_CONNECTED; gpRedDecController->PacketCounter = 0; // initialize the parameters related to the DEC gpRedDecController->DetectorParams.ClocksPerReadout = 32; gpRedDecController->DetectorParams.ReadoutsPerRamp = 8; gpRedDecController->DetectorParams.ReadoutValidity = INVALID; gpRedDecController->DetectorParams.CreCtrlReg = 0x8C; gpRedDecController->DetectorParams.CreCtrlRegCommand = 0x8C; gpRedDecController->TemporaryDetectorParams.ClocksPerReadout = 32; gpRedDecController->TemporaryDetectorParams.ReadoutsPerRamp = 8; gpRedDecController->TemporaryDetectorParams.SimulReg = 60000; gpRedDecController->TemporaryDetectorParams.BiasRCommand = 0; gpRedDecController->TemporaryDetectorParams.BiasDCommand = 0; gpRedDecController->TemporaryDetectorParams.CreCtrlReg = 0x8C; gpRedDecController->TemporaryDetectorParams.CreCtrlRegCommand = 0x8C; UNLOCK_WRITE_RES_PARAMS; // signal event to allow first write command to execute KS_EventSignal(gaEventsSmcsTransmitCompleted[CHANNEL_RED_DEC_ID]); } /* TASK_FUNCTION : void RedDecCtrl() ********************************* AUTHOR : AMazy This is the function implementing the Red Dec Controller Task. It waits for messages on a FIFO and executes the requested commands by sending 1335 packets to the Red DEC. The FIFO messages mainly come from the Sequencer */ void RedDecCtrl() { //declare a structure used to receive message on the fifo DecControllerFifoMessage msg; int i=0; int waitCounter = 0; InitializeRedDecCtrl(); while(1) { // wait for a message from the sequencer KS_FIFOGetW(RED_DEC_FIFO, &msg); // according to the message type, execute the related action switch (msg.Type) { case MSG_DEC_CTRL_SET_HEATER_CURRENT : { SendCommandToRedDEC(DEC_HEATER_COMMAND, gpRedDecController->DetectorParams.HeaterCurrent); };break; case MSG_DEC_CTRL_SET_FLASHER_CURRENT : { SendCommandToRedDEC(DEC_FLASHER_COMMAND, gpRedDecController->DetectorParams.FlasherCurrent); };break; case MSG_DEC_CTRL_SWITCH_FLASHER_ON : { SendCommandToRedDEC(DEC_FLASHER_COMMAND, gpRedDecController->DetectorParams.FlasherCurrent); SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_FLASHER_POWER, K_BMASK_DEC_COMMAND_FLASHER_POWER_ON); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); };break; case MSG_DEC_CTRL_SWITCH_FLASHER_OFF : { SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_FLASHER_POWER, K_BMASK_DEC_COMMAND_FLASHER_POWER_OFF); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); };break; case MSG_DEC_CTRL_SWITCH_HEATER_ON : { SendCommandToRedDEC(DEC_HEATER_COMMAND, gpRedDecController->DetectorParams.HeaterCurrent); SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_HEATER_POWER, K_BMASK_DEC_COMMAND_HEATER_POWER_ON); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); };break; case MSG_DEC_CTRL_SWITCH_HEATER_OFF : { SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_HEATER_POWER, K_BMASK_DEC_COMMAND_HEATER_POWER_OFF); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); };break; case MSG_DEC_CTRL_LOAD_PARAMETERS : { // not all the bits that have been written in the CreCtrlReg parameter during the write command must be transmitted to DEC SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_WRITABLE_BITS, gpRedDecController->DetectorParams.CreCtrlRegCommand); // load the parameters into the DEC board SendCommandToRedDEC(DEC_CLOCKS_PER_READOUT, gpRedDecController->DetectorParams.ClocksPerReadout); SendCommandToRedDEC(DEC_READOUTS_PER_RAMP, gpRedDecController->DetectorParams.ReadoutsPerRamp); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); SendCommandToRedDEC(DEC_BIAS_R_COMMAND, gpRedDecController->DetectorParams.BiasRCommand); SendCommandToRedDEC(DEC_ZERO_BIAS_COMMAND, gpRedDecController->DetectorParams.BiasDCommand); SendCommandToRedDEC(DEC_SIMUL_REG, gpRedDecController->DetectorParams.SimulReg); };break; case MSG_DEC_CTRL_SWITCH_DEC_ON : { //switch it on SET_BITS(gpMim->ControlWord, K_BMASK_MIM_RED_DEC_POWER_CONTROL, K_BMASK_MIM_RED_DEC_POWER_ON); //validate the HK related to Red DEC (without the hk related to detector array) for (i = DMC_DECR_HEAT_C; i <= DMC_DECR_RA_CO_1; ++i) { VALIDATE_HK(i); } for (i = DMC_DECR_FLASH_C; i <= DMC_DECR_RA_CO_2; ++i) { VALIDATE_HK(i); } //invalidate the diagnostic hk related to Red DEC for (i = DMC_DR_TS12CBS_1; i <= DMC_DECR_R5V_2; ++i) { VALIDATE_HK(i); } //validate the hk related to the spectro array for (i = DMC_DECR_VDDD_1; i <= DMC_DECR_IGND_1; ++i) { VALIDATE_HK(i); } for (i = DMC_DECR_VDDD_2; i <= DMC_DECR_IGND_2; ++i) { VALIDATE_HK(i); } //wait that the switch on relay is activated KS_TaskSleep(200); LOCK_WRITE_RES_PARAMS; SET_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON); UNLOCK_WRITE_RES_PARAMS; //wait 5 seconds that the dec initialize and detect if it is powered off in the meanwhile waitCounter = 5; while (TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON) && (waitCounter >= 0)) { KS_TaskSleep(1000); waitCounter--; } // if the DEC has been powered off while we were waiting, exit if (!TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON)) { continue; } #ifdef SIMULATOR LOCK_WRITE_RES_PARAMS; SET_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON | K_BMASK_TASK_STATUS_LINK_CONNECTED); UNLOCK_WRITE_RES_PARAMS; #else //SIMULATOR //reset the DEC Base FPGA SET_BIT(gpFPGA->ControlRegister, K_BMASK_TIMING_MASTER_RESET); WriteFpgaRegisters(); CLEAR_BIT(gpFPGA->ControlRegister, K_BMASK_TIMING_MASTER_RESET); WriteFpgaRegisters(); //wait the FPGA initializes KS_TaskSleep(100); //re-initialize the communication StartLink(CHANNEL_RED_DEC, RESET_SMCS); LOCK_READ_RES_PARAMS; // wait that the DEC initializes the connection on the other side // or that a detector simulator is started (when gpRedDecRec->TaskStatus have been modified) while (IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_NOT_CONNECTED) && IS(gpRedDecRec->TaskStatus, K_BMASK_SIMULATION, K_BMASK_REAL_TIMING + K_BMASK_REAL_READOUTS) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON)) { UNLOCK_READ_RES_PARAMS; KS_TaskSleep(1000); LOCK_READ_RES_PARAMS; } UNLOCK_READ_RES_PARAMS; #endif //SIMULATOR };break; case MSG_DEC_CTRL_SWITCH_DETECTOR_ON : { //update CRE Control Register and send the new value to the DEC BASE FPGA SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_DETECTOR_POWER, K_BMASK_DEC_COMMAND_DETECTOR_POWER_ON); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); };break; case MSG_DEC_CTRL_SWITCH_DETECTOR_OFF : { //update CRE Control Register and send the new value to the DEC BASE FPGA SET_BITS(gpRedDecController->DetectorParams.CreCtrlReg, K_BMASK_DEC_COMMAND_DETECTOR_POWER, K_BMASK_DEC_COMMAND_DETECTOR_POWER_OFF); SendCommandToRedDEC(DEC_CRE_CTRL_REG, gpRedDecController->DetectorParams.CreCtrlReg); };break; default : { SetError(ERR_DEC_CONTROLLER_UNKNOWN_FIFO_MSG); } }; } } /* CMD_FUNCTION : BOOL CommandSwitchOnRedDEC(CommandParameter paramNotUsed) ************************************************************************ AUTHOR : Amazy USE : Power On the Red DEC */ BOOL CommandSwitchOnRedDEC(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type = MSG_DEC_CTRL_SWITCH_DEC_ON; // if the red CREs are on, reject the command (the master reset would switch them off brutally. That is not good) if ((IS(gpBlueDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpBlueDecRec->DecHk.CreStatusRegFirst, 1))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_OTHER_CRE_ON); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SWON_R_DEC); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwitchOffRedDEC(CommandParameter paramNotUsed) ************************************************************************* AUTHOR : Amazy USE : Power Off the Red DEC */ BOOL CommandSwitchOffRedDEC(CommandParameter paramNotUsed) { int i=0; //stop the 1355 link StopLink(CHANNEL_RED_DEC); // cut the power off SET_BITS(gpMim->ControlWord, K_BMASK_MIM_RED_DEC_POWER_CONTROL, K_BMASK_MIM_RED_DEC_POWER_OFF); //invalidate the HK related to Red DEC (including the hk related to detector array) for (i = DMC_DECR_VDDD_1; i <= DMC_DECR_RA_CO_2; ++i) { INVALIDATE_HK(i); } //invalidate the diagnostic hk related to Red DEC for (i = DMC_DR_TS12CBS_1; i <= DMC_DECR_R5V_2; ++i) { INVALIDATE_HK(i); } //update the status words LOCK_WRITE_RES_PARAMS; CLEAR_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON); SET_BITS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_NOT_CONNECTED); UNLOCK_WRITE_RES_PARAMS; SequencerSendAck(DMC_SWOF_R_DEC); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwitchOnRedSpectroArray(CommandParameter paramNotUsed) ********************************************************************************* AUTHOR : Amazy USE : Power On the Red Spectro array */ BOOL CommandSwitchOnRedSpectroArray(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type = MSG_DEC_CTRL_SWITCH_DETECTOR_ON; // if the link is not connected or the DEC is off, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SWON_R_SPEC); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwitchOffRedSpectroArray(CommandParameter paramNotUsed) ********************************************************************************** AUTHOR : Amazy USE : Power Off the Red Spectro array */ BOOL CommandSwitchOffRedSpectroArray(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type = MSG_DEC_CTRL_SWITCH_DETECTOR_OFF; // send the command only if the DEC is powered on and connected if ((IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { KS_FIFOPut(RED_DEC_FIFO, &msg); } //send the PACK anyway SequencerSendAck(DMC_SWOF_R_SPEC); return FALSE; } /* CMD_FUNCTION : BOOL CommandValidateScienceDataRed(CommandParameter paramNotUsed) ******************************************************************************** AUTHOR : Amazy USE : Validates the Red Science Data */ BOOL CommandValidateScienceDataRed(CommandParameter paramNotUsed) { gpBolController->ReadoutValidityRed = VALID; gpRedDecController->DetectorParams.ReadoutValidity = VALID; SequencerSendAck(DMC_VAL_SCI_DATA_R); return TRUE; } /* CMD_FUNCTION : BOOL CommandInvalidateScienceDataRed(CommandParameter paramNotUsed) ********************************************************************************** AUTHOR : Amazy USE : Invalidates the Red Science Data */ BOOL CommandInvalidateScienceDataRed(CommandParameter paramNotUsed) { gpBolController->ReadoutValidityRed = INVALID; gpRedDecController->DetectorParams.ReadoutValidity = INVALID; SequencerSendAck(DMC_INVAL_SCI_DATA_R); return TRUE; } /* CMD_FUNCTION : BOOL CommandSetRedSpectroParameters(CommandParameter paramNotUsed) ********************************************************************************* AUTHOR : Amazy USE : Load the parameters of the Red Spectrometer Detector Array in the DEC board */ BOOL CommandSetRedSpectroParameters(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type = MSG_DEC_CTRL_LOAD_PARAMETERS; //both arrays need to receive new parameters together so they stay synchronized if (gpRedDecController->TemporaryDetectorParams.ReadoutsPerRamp < 2) { SequencerSendNack(0, INVALID_PARAMETER); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); return FALSE; } // if we are in simulation mode if (IS(gpRedDecRec->TaskStatus, K_BMASK_SIMULATION_DATA, K_BMASK_SIMULATED_READOUTS)) { // copy the parameters from the temporary buffer to the final one MEMCPY(&(gpRedDecController->DetectorParams), &(gpRedDecController->TemporaryDetectorParams), 6); SequencerSendAck(DMC_SET_PAR_R_SPEC); return FALSE; } else { // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } // copy the parameters from the temporary buffer to the final one MEMCPY(&(gpRedDecController->DetectorParams), &(gpRedDecController->TemporaryDetectorParams), 6); KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SET_PAR_R_SPEC); return FALSE; } } /* FUNCTION : void SendCommandToRedDEC(int address, int value) *********************************************************** AUTHOR : AMazy USE : Sends a command to the DEC (to set the value of one register). NOTE : if you change something to this function, apply the same changes to the SendCommandToBlueDEC function in "BDecCtrl.c" */ void SendCommandToRedDEC(int address, int value) { #ifndef SIMULATOR //PROTOCOL = //1 character ( corresponding to the most significant byte of the 32 bit word ) transports the parameter address, //1 character is unused //2 characters contain the value. int buffer = 0; buffer = address << 24; buffer |= value & 0x0000FFFF; LINK_1355_WRITE(CHANNEL_RED_DEC, 1, &buffer); #endif //SIMULATOR } /* CMD_FUNCTION : BOOL CommandSetRedSpectroHeaterCurrent(CommandParameter param) ***************************************************************************** AUTHOR : Amazy USE : Set the heater current of red DEC */ BOOL CommandSetRedSpectroHeaterCurrent(CommandParameter param) { DecControllerFifoMessage msg; msg.Type= MSG_DEC_CTRL_SET_HEATER_CURRENT; gpRedDecController->DetectorParams.HeaterCurrent = param.Int & 0x00000FFF; // only 12bits are used // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SET_R_SPEC_HEAT_C); return FALSE; } /* CMD_FUNCTION : BOOL CommandSetRedSpectroFlasherCurrent(CommandParameter param) ****************************************************************************** AUTHOR : Amazy USE : Set the flasher current of red DEC */ BOOL CommandSetRedSpectroFlasherCurrent(CommandParameter param) { DecControllerFifoMessage msg; msg.Type= MSG_DEC_CTRL_SET_FLASHER_CURRENT; gpRedDecController->DetectorParams.FlasherCurrent = param.Int & 0x00000FFF; // only 12bits are used // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SET_R_SPEC_FLASH_C); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwOnRedHeater(CommandParameter paramNotUsed) *********************************************************************** AUTHOR : Amazy USE : Switches on the Heater of red DEC */ BOOL CommandSwOnRedHeater(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type= MSG_DEC_CTRL_SWITCH_HEATER_ON; gpRedDecController->DetectorParams.HeaterCurrent = 0; // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SWON_RD_HEATER); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwOffRedHeater(CommandParameter paramNotUsed) ************************************************************************ AUTHOR : Amazy USE : Switches off the Heater of red DEC */ BOOL CommandSwOffRedHeater(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type= MSG_DEC_CTRL_SWITCH_HEATER_OFF; // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SWOF_RD_HEATER); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwOnRedFlasher(CommandParameter paramNotUsed) ************************************************************************ AUTHOR : Amazy USE : Switches on the Flasher of red DEC */ BOOL CommandSwOnRedFlasher(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type= MSG_DEC_CTRL_SWITCH_FLASHER_ON; gpRedDecController->DetectorParams.FlasherCurrent = 0; // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SWON_RD_FLASHER); return FALSE; } /* CMD_FUNCTION : BOOL CommandSwOffRedFlasher(CommandParameter paramNotUsed) ************************************************************************* AUTHOR : Amazy USE : Switches off the Flasher of red DEC */ BOOL CommandSwOffRedFlasher(CommandParameter paramNotUsed) { DecControllerFifoMessage msg; msg.Type= MSG_DEC_CTRL_SWITCH_FLASHER_OFF; // if the link is not connected, reject the command if (!(IS(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_LINK_STATUS, K_BMASK_TASK_STATUS_LINK_CONNECTED) && TEST_ONE_BIT(gpRedDecController->TaskStatus, K_BMASK_TASK_STATUS_DEC_CTRL_POWERED_ON))) { SequencerSendNack(0, COULD_NOT_EXECUTE_COMMAND); SetSequencerError(ERR_SEQUENCER_COULD_NOT_EXECUTE_COMMAND); SetError(ERR_DEC_CONTROLLER_LINK_NOT_CONNECTED); return FALSE; } KS_FIFOPut(RED_DEC_FIFO, &msg); SequencerSendAck(DMC_SWOF_RD_FLASHER); return FALSE; }