/* $Workfile: $ ** ** Title: rdSh.c ** ** Author: J Chiralo the Hammers Company, Inc. ** ** $Revision: 1.35 $ ** ** Checked in $Date: 2007/07/05 19:39:44 $ ** Last Modified $Modtime: $ ** Last Modified By $Author: wang $ ** *********************************************************************** ** ** Purpose: Read, decode and print the data contained within an Image Header ** as defined for the SECCHI instrument. ** ** Assumptions and External Effects: ** ** None ** ** Modification History: ** $Log: rdSh.c,v $ ** Revision 1.35 2007/07/05 19:39:44 wang ** Linux version fixes for time printout ** ** Revision 1.34 2007/06/11 20:09:53 wang ** Bugz 94 - LED pulses ** ** Revision 1.33 2007/05/03 17:49:27 wang ** fixed format for IP time ** ** Revision 1.32 2007/05/03 17:14:24 wang ** fixed format for times ** ** Revision 1.31 2007/04/25 15:08:13 wang ** Added more time validity checking ** ** Revision 1.30 2007/04/25 14:46:30 wang ** Added time validity checking ** ** Revision 1.29 2007/01/18 20:04:09 wang ** Recognize TBL ** ** Revision 1.28 2006/10/13 19:57:49 wang ** Update to FSW 5.0+ ** ** Revision 1.27 2006/09/29 15:43:01 wang ** Linux conditional compiles ** ** Revision 1.26 2006/01/11 18:03:13 wang ** Fix Actual Exp Time when exposure is skipped ** ** Revision 1.25 2005/12/08 21:45:51 wang ** Updated to FSW 4.7 ** ** Revision 1.24 2005/11/15 21:30:10 wang ** Validity check on time ** ** Revision 1.23 2005/06/21 15:45:02 secchib ** *** empty log message *** ** ** Revision 1.22 2005/05/16 13:28:56 wang ** added actualPolarPosition2 ** ** Revision 1.21 2005/05/12 21:29:45 wang ** rdSh Version 4 ** ** Revision 1.2 2005/05/11 22:55:10 wang ** Version 4 header ** ** Revision 1.1 2005/05/11 14:51:08 wang ** VER4 header support ** ** Revision 1.20 2005/04/13 23:24:25 wang ** New IP codes and header VER3 changes ** ** Revision 1.19 2005/04/01 00:17:34 jchiralo ** Changed s/c status bits decoding to hex with bit mask ** ** Revision 1.18 2005/03/28 16:06:47 jchiralo ** Added decode of start time fields for CCD clear and image readout ** ** Revision 1.17 2005/03/21 15:08:14 wang ** numInSeq added and new IP codes ** ** Revision 1.16 2005/03/18 16:31:34 wang ** Updated IP codes and added version 1 (no bias vars) reader to Makefile as rdShv1 ** ** Revision 1.15 2005/03/18 08:27:45 wang ** Added bias mean and std ** ** Revision 1.14 2005/02/02 20:48:02 wang ** Added IP codes ** ** Revision 1.13 2005/01/31 19:33:32 jchiralo ** Changes to reflect new spacewire error codes and door status values ** ** Revision 1.12 2004/11/12 16:42:41 jchiralo ** Moved subsecsStr defn to obey C rules ** ** Revision 1.11 2004/11/03 15:35:26 jchiralo ** Fixed day calculation for time and changed polar to cmdPolarPosition in output ** ** Revision 1.10 2004/10/29 18:56:23 jchiralo ** Changed some fields to remove (:) ** ** Revision 1.9 2004/10/27 21:59:14 jchiralo ** Added value decoding for enums and time; reformatted output ** */ #include #include "hdr.h" #define FALSE 0 #define TRUE 1 #define HEADER_SIZE 300 #define DEBUG char *sccs_string="$Revision: 1.35 $ $Date: 2007/07/05 19:39:44 $ $Author: wang $"; #ifdef LITTLE_ENDIAN #define FIX_WORD(i) ((((i)>>24) & 0x000000ff) | (((i)>>8) & 0x0000ff00) \ | (((i)<<8) & 0x00ff0000) | (((i)<<24) & 0xff000000)) #define SWAP_BYTE(i) ((((i) & 0x00ff) << 8) | (((i) & 0xff00) >> 8)) double fix_double( double *number) { uint32 *hi, *lo, *hidw, *lodw; double swapped_double, *dblptr; hi = (uint32 *) number; lo = hi + 1; dblptr = &swapped_double; hidw = (uint32 *) dblptr; lodw = hidw + 1; *lodw = FIX_WORD(*hi); *hidw = FIX_WORD(*lo); //printf("fix_double():%x %x %x %x %10.3f\n",*hi, *lo,*hidw,*lodw,swapped_double); return swapped_double; } #else #define FIX_WORD(i) (i) #define SWAP_BYTE(i) (i) double fix_double( double *number) { return *number; } #endif /*************************************************************************/ int months_days (int year,int month) { int days=0; switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: days = 31; break; case 4: case 6: case 9: case 11: days = 30; break; case 2: days = 28; if ((year % 4) == 0) { if ((year % 400) == 0) days = 29; else if ((year % 100) != 0) days = 29; } break; } return(days); } /*************************************************************************/ uint32 tics_in_year (int current_year) { int result; result = SECONDS_IN_ONE_YEAR; if ((current_year % 4) == 0) { if ((current_year % 400) == 0) result += SECONDS_IN_ONE_DAY; /* Add extra day for leap year */ else if ((current_year % 100) != 0) result += SECONDS_IN_ONE_DAY; /* Add extra day for leap year */ } return (result); } // Write the current time to the input structure in DOS time format // void translateTime ( double timeValue ) { uint32 curr_timestamp; int current_year; int current_month; int current_day; int current_hour; int current_minute; int current_second; char subsecsStr[5]; curr_timestamp = (uint32)timeValue; if (timeValue > 3000000000.0 || timeValue < 0.0) { printf(" 00-000-00:00:00:00.000"); return; } if (curr_timestamp < SECONDS_SINCE_EPOCH_TO_DOS) { ///// // S/C time is less than the initial DOS time // so assign the initial DOS value. ///// current_year = 0; current_month = 0; current_day = 0; current_hour = 0; current_minute = 0; current_second = 0; } ///// else // Calculate DOS time from spacecraft time { ///// ///// // Subtract seconds from epoch to DOS epoch of 1/1/80 0:0:0 ///// curr_timestamp -= SECONDS_SINCE_EPOCH_TO_DOS; current_year = DOS_EPOCH_YEAR; while (curr_timestamp >= tics_in_year (current_year)) { /* Take out 365/366 days */ curr_timestamp -= tics_in_year (current_year); current_year++; } current_month = DOS_EPOCH_MONTH; current_day = DOS_EPOCH_DAY; while (curr_timestamp >= months_days(current_year, current_month) * SECONDS_IN_ONE_DAY ) { /* Take out 28/29/30/31 days */ curr_timestamp -= months_days(current_year, current_month) * SECONDS_IN_ONE_DAY; current_day += months_days ( current_year, current_month ); current_month++; } while (curr_timestamp >= SECONDS_IN_ONE_DAY) { /* Remove each full day so far this month */ curr_timestamp -= SECONDS_IN_ONE_DAY; current_day++; } current_hour = 0; while (curr_timestamp >= SECONDS_IN_ONE_HOUR) { /* Remove each full hour so far today */ curr_timestamp -= SECONDS_IN_ONE_HOUR; current_hour++; } current_minute = 0; while (curr_timestamp >= SECONDS_IN_ONE_MINUTE) { /* Remove each full minute so far this hour */ curr_timestamp -= SECONDS_IN_ONE_MINUTE; current_minute++; } current_second = 0; while (curr_timestamp >= 1) { /* Remove each full second so far this minute */ curr_timestamp -= 1; current_second++; } }// end else for calculation // print the calculated values if ( current_year > 2000 ) printf(" %02u",current_year-2000); else printf(" %02u",current_year); printf("-%03u", current_day); printf("-%02u", current_hour); printf(":%02u", current_minute); printf(":%02u", current_second); sprintf ( &subsecsStr[0],"%3.3f ", (double)timeValue - (double)((int)timeValue) ); printf ("%s", &subsecsStr[1]); } int unpack_base_sci_hdr() { uint32 icount = 0,hi1=0,hi2=0; double rawTime = 0.0; char codestr[5]; printf("\n Image Header-------------------------------" ); printf("\nctrl.filename: %s" , (uint32)m_baseHeader.filename ); printf("\nctrl.eHeaderTypeFlag: %u" ,m_baseHeader.eHeaderTypeFlag); if ( m_baseHeader.eHeaderTypeFlag == 0 ) printf (" SPACEWEATHER"); if ( m_baseHeader.eHeaderTypeFlag == 1 ) printf (" NOMINAL"); if ( m_baseHeader.eHeaderTypeFlag == 2 ) printf (" EXTENDED"); printf("\nctrl.Version: %02u" ,m_baseHeader.version ); printf("\nctrl.osNumber: %05u" ,SWAP_BYTE(m_baseHeader.osNumber) ); printf("\nctrl.critEvent: %05u" ,SWAP_BYTE(m_baseHeader.critEvent) ); printf("\nctrl.imgctr %05u" ,SWAP_BYTE(m_baseHeader.imgCtr) ); printf(": imgseq %05u" ,m_baseHeader.imgSeq ); printf(": numInSeq %05u" ,m_baseHeader.numInSeq ); printf("\nctrl.telescopeImgCnt %05u" ,SWAP_BYTE(m_baseHeader.telescopeImgCnt) ); printf("\nceb.sumrow %02u" ,m_baseHeader.sumrow ); printf(": sumcol %02u" ,m_baseHeader.sumcol ); printf("\nmech.actualFilterPosition %03u" ,m_baseHeader.actualFilterPosition); printf("\nmech.actualPolarPosition %03u" ,m_baseHeader.actualPolarPosition ); printf("\nmech.actualPolarPosition2 %03u" ,m_baseHeader.actualPolarPosition2 ); printf("\nceb.SEBxsum %02u" ,m_baseHeader.sebxsum ); printf(": SEBysum %02u" ,m_baseHeader.sebysum ); #ifdef VER2 printf("\nceb.meanBias %10u" ,m_baseHeader.meanBias ); printf(": stddevBias %10u" ,m_baseHeader.stddevBias ); #endif #ifdef VER3 printf("\nceb.meanBias %10d" ,m_baseHeader.meanBias ); printf(": stddevBias %10u" ,m_baseHeader.stddevBias ); #endif #ifdef VER4 printf("\nceb.meanBias %10d" ,FIX_WORD(m_baseHeader.meanBias) ); printf(": stddevBias %10u" ,FIX_WORD(m_baseHeader.stddevBias) ); #endif printf("\nip.Cmd_Log_0..19= "); /* check for HI SB clear */ for (icount = 0; icount < N_IMG_PROC_CMD; icount++) { if (m_baseHeader.ipCmdLog[icount] == 33) hi1 = 1; if (m_baseHeader.ipCmdLog[icount] == 35) hi2 = 1; } for(icount = 0; icount < N_IMG_PROC_CMD; icount++) { if ((hi1 || hi2) && icount < 2) printf(" TBL "); else { ipcode2str( m_baseHeader.ipCmdLog[icount], codestr); printf(" %s " ,codestr); } } printf("\ntime.actualExpDuration %08u (4 usec) %08u usec ( Close time minus open time )" , FIX_WORD(m_baseHeader.actualExpDuration), FIX_WORD(m_baseHeader.actualExpDuration ) * 4ul); printf("\ntime.actualExpTime %14.3f " , fix_double(&m_baseHeader.actualExpTime) ); if(fix_double(&m_baseHeader.actualExpTime) >= 0.00) translateTime( fix_double(&m_baseHeader.actualExpTime) ); printf("\ntime.actualExpTime_2 %14.3f " , fix_double(&m_baseHeader.actualExpTime_2 )); if(fix_double(&m_baseHeader.actualExpTime_2) >= 0.00) translateTime( fix_double(&m_baseHeader.actualExpTime_2 )); printf("\n\n"); return(FALSE); } int unpack_nom_sci_hdr() { uint32 icount = 0; printf ("\n cImageHdr::Nominal Header----------" ); printf ("\nctrl.platform_id %u" ,m_nominalHeader.platformID); switch ( m_nominalHeader.platformID ) { case 1: printf (" STEREO-A"); break; case 2: printf (" STEREO-B"); break; } printf ("\nctrl.instrument %u" ,m_nominalHeader.telescopeID); switch ( m_nominalHeader.telescopeID ) { case 1: printf (" COR2"); break; case 2: printf (" COR1"); break; case 3: printf (" EUVI"); break; case 4: printf (" HI2"); break; case 5: printf (" HI1"); break; } printf ("\nctrl.imageType %02u" ,m_nominalHeader.imageType); switch ( m_nominalHeader.imageType ) { case 0: printf (" NORMAL"); break; case 1: printf (" DARK"); break; case 2: printf (" DOUBLE"); break; case 3: printf (" LED"); break; case 4: printf (" CONTINUOUS"); break; case 5: printf (" SERIES"); break; } printf ("\nctrl.sync %u" ,m_nominalHeader.sync); printf("\ntime.cmdExpDuration: %05u [1.024msec units for SCIP] or [2 msec for HI]" ,SWAP_BYTE(m_nominalHeader.cmdExpDuration) ); printf("\ntime.cmdExpDuration_2: %05u" ,SWAP_BYTE(m_nominalHeader.cmdExpDuration_2) ); printf ("\nctrl.campaignSet %05u" ,m_nominalHeader.campaignSet); printf ("\nceb.offset %03u" ,SWAP_BYTE(m_nominalHeader.offset)); printf ("\nceb.gain %03u" ,m_nominalHeader.gain); printf ("\nceb.gainMode %u" ,m_nominalHeader.gainMode); printf ("\nceb.clrTableID %02u" ,m_nominalHeader.clrTableID); printf ("\nceb.readoutTableID %02u" ,m_nominalHeader.readoutTableID); printf ("\nceb.p1col %04u" ,SWAP_BYTE(m_nominalHeader.p1col)); printf (" : p1row %04u" ,SWAP_BYTE(m_nominalHeader.p1row)); printf ("\nceb.p2col %04u" ,SWAP_BYTE(m_nominalHeader.p2col)); printf (" : p2row %04u" ,SWAP_BYTE(m_nominalHeader.p2row)); printf ("\nceb.imgBufferOffset %02u" ,m_nominalHeader.imgBufferOffset); printf ("\nceb.CEB-Link-status %02u" ,m_nominalHeader.CEBIntfStatus); switch ( m_nominalHeader.CEBIntfStatus ) { case 0: printf (" SUCCESSFUL_RESPONSE"); break; case -1 : printf (" NO_COMMANDED_ACTION // No activity has yet occurred"); break; case 1 : printf (" START_NOT_ACKNOWLEDGED // Start sequence command not acknowledged"); break; case 2 : printf (" STOP_NOT_ACKNOWLEDGED // Stop sequence command not acknowledged"); break; case 3 : printf (" WRITE_NOT_ACKNOWLEDGED // Data byte write to the Camera interface failed "); break; case 4 : printf (" INVALID_COMMAND_RESPONSE // Invalid command received by Camera box"); break; case 5 : printf (" PARITY_ERROR_RESPONSE // Parity error detected by Camera box"); break; case 6 : printf (" NO_STOP_BIT_RESPONSE // No stop bit error detected by Camera box"); break; case 7 : printf (" SEND_ON_LINK_FAILED // Unable to send message on link"); break; case 8 : printf (" READ_ON_LINK_FAILED // Unable to perform read on link"); break; case 9 : printf (" CAMERA_ADDRESS_NOT_ACKNOWLEDGED // Address error detected by Camera box"); break; case 10 : printf (" READ_ADDRESS_NOT_ACKNOWLEDGED // Read address for sequence not acknowledged"); break; case 11 : printf (" INVALID_OFFSET_VALUE // Value of Offset is not within limits"); break; case 12 : printf (" INVALID_GAIN_VALUE // Value of Gain is not within limits"); break; case 13 : printf (" INVALID_MODE_VALUE // Value of Mode is not within limits"); break; case 14 : printf (" OFFSET_WRITE_FAILED // CDS programming of offset failed"); break; case 15 : printf (" GAIN_WRITE_FAILED // CDS programming of gain failed"); break; case 16 : printf (" MODE_WRITE_FAILED // CDS programming of mode failed"); break; case 17 : printf (" FLIGHT_TABLE_NOT_AVAILABLE // Init of default flight tables failed"); break; case 18 : printf (" WAVE_TABLE_PATCH_FAILED // Patching wave table data to camera failed"); break; case 19 : printf (" READOUT_TABLE_PATCH_FAILED // Patching readout table data to camera failed"); break; case 20 : printf (" CAMERA_LINK_NOT_AVAILABLE // Link to CEB is not available"); break; case 21 : printf (" CCD_INTERFACE_ANOMALY // One or more CEB interfaces have an anomaly"); break; } printf ("\nceb.CCD-Intf-status %02u" ,m_nominalHeader.CCDIntfStatus); switch ( m_nominalHeader.CCDIntfStatus ) { case 0: printf (" CAMERA_NOT_READY"); break; case 1: printf (" CAMERA_READY"); break; case 2: printf (" CAMERA_ERROR"); break; case 3: printf (" CAMERA_UNKNOWN_STATE"); break; } /* Instrument uses a double format for time from epoch 1958 */ /* - Jan 01 00:00:00 UTC */ /* time of exposure uploaded NOT including lt_offset */ printf ("\ntime.cmdExptime %14.3f" ,fix_double(&m_nominalHeader.cmdExpTime)); if(fix_double(&m_nominalHeader.cmdExpTime) > 0.00) translateTime( fix_double(&m_nominalHeader.cmdExpTime )); printf ("\ntime.lightTravelOffsetTime %05u (msec)" ,m_nominalHeader.lightTravelOffsetTime); printf ("\nmech.cmdFilterPosition %u" ,m_nominalHeader.cmdFilterPosition); printf ("\nmech.cmdPolarPosition %03u" ,m_nominalHeader.cmdPolarPosition); printf (" : cmdPolarPosition_2 %03u" ,m_nominalHeader.cmdPolarPosition_2); /* led id 0=no led used */ printf ("\nmech.LED Mode %u" ,m_nominalHeader.cmdLEDMode); switch ( m_nominalHeader.cmdLEDMode ) { case 1: printf (" RED"); break; case 2: printf (" PURPLE"); break; case 3: printf (" BLUE"); break; } printf (" : pulses %07u" ,FIX_WORD(m_nominalHeader.cmdLEDPulses)); /* ACTUALS */ printf ("\nsc.Pre-exposure_S/C_status 0x%x" ,SWAP_BYTE(m_nominalHeader.preExpSCStatus ) & 0x03d0); if ( SWAP_BYTE(m_nominalHeader.preExpSCStatus) & 0x0200 ) printf (" [offPointing]"); if ( SWAP_BYTE(m_nominalHeader.preExpSCStatus) & 0x0100 ) printf (" [finePointing]"); if ( SWAP_BYTE (m_nominalHeader.preExpSCStatus) & 0x0080 ) printf (" [hgaMotionWarning]"); if ( SWAP_BYTE(m_nominalHeader.preExpSCStatus) & 0x0040 ) printf (" [propulsionWarning]"); if ( SWAP_BYTE(m_nominalHeader.preExpSCStatus) & 0x0010 ) printf (" [shutdownWarning]"); printf ("\nsc.Post-exposure_S/C_status 0x%x" ,SWAP_BYTE(m_nominalHeader.postExpSCStatus) & 0x03d0); if ( SWAP_BYTE(m_nominalHeader.postExpSCStatus) & 0x0200 ) printf (" [offPointing]"); if ( SWAP_BYTE(m_nominalHeader.postExpSCStatus) & 0x0100 ) printf (" [finePointing]"); if ( SWAP_BYTE(m_nominalHeader.postExpSCStatus) & 0x0080 ) printf (" [hgaMotionWarning]"); if ( SWAP_BYTE(m_nominalHeader.postExpSCStatus) & 0x0040 ) printf (" [propulsionWarning]"); if ( SWAP_BYTE(m_nominalHeader.postExpSCStatus) & 0x0010 ) printf (" [shutdownWarning]"); /* time of exposure actual NOT including lt_offset */ printf ("\ntime.actualOpenTime %05u (4 usec) %06u usec" ,FIX_WORD(m_nominalHeader.actualOpenTime),FIX_WORD(m_nominalHeader.actualOpenTime)*4); printf ("\ntime.actualCloseTime %05u (4 usec) %06u usec" ,FIX_WORD(m_nominalHeader.actualCloseTime) ,FIX_WORD(m_nominalHeader.actualCloseTime) *4); printf ("\ntime.actualOpenTime_2 %05u (4 usec) %06u usec" , FIX_WORD(m_nominalHeader.actualOpenTime_2) ,FIX_WORD(m_nominalHeader.actualOpenTime_2) *4); printf ("\ntime.actualCloseTime_2 %05u (4 usec) %06u usec" , FIX_WORD(m_nominalHeader.actualCloseTime_2) ,FIX_WORD(m_nominalHeader.actualCloseTime_2) *4); printf ("\ntime.actualExpDuration_2 %05u (4 usec) %06u usec" ,m_baseHeader.actualExpDuration_2,m_baseHeader.actualExpDuration_2*4); /* shutter during exposure open=1 closed = 0*/ printf ("\nmech.actualShutterPosition %u " ,m_nominalHeader.actualShutterPosition); if ( m_nominalHeader.actualShutterPosition == 0 ) printf (" closed"); if ( m_nominalHeader.actualShutterPosition == 1 ) printf (" open"); printf (" (during exposure)"); /* CW or CCW */ printf ("\nmech.actualShutterDirection %u" ,m_nominalHeader.actualShutterDirection); if ( m_nominalHeader.actualShutterDirection == 1 ) printf (" CW"); if ( m_nominalHeader.actualShutterDirection == 2 ) printf (" CCW"); printf ("\nmech.actualFilterDirection %u" ,m_nominalHeader.actualFilterDirection); if ( m_nominalHeader.actualFilterDirection == 1 ) printf (" CW"); if ( m_nominalHeader.actualFilterDirection == 2 ) printf (" CCW"); printf ("\nmech.actualPolarDirection %u" ,m_nominalHeader.actualPolarDirection); if ( m_nominalHeader.actualPolarDirection == 1 ) printf (" CW"); if ( m_nominalHeader.actualPolarDirection == 2 ) printf (" CCW"); /* door open=1 or closed=0 */ printf ("\nmech.actualDoorPosition %u" ,m_nominalHeader.actualDoorPosition); if ( m_nominalHeader.actualDoorPosition == 0 ) printf (" closed"); if ( m_nominalHeader.actualDoorPosition == 1 ) printf (" in_transit"); if ( m_nominalHeader.actualDoorPosition == 2 ) printf (" open"); if ( m_nominalHeader.actualDoorPosition == 3 ) printf (" off"); if ( m_nominalHeader.actualDoorPosition == 4 ) printf (" error"); if ( m_nominalHeader.actualDoorPosition == 255 ) printf (" no_data"); printf ("\ntime.actualReadoutTime %07u (usec)" ,FIX_WORD(m_nominalHeader.actualReadoutTime)); /* Image processing */ printf ("\nip.Function %02u" ,m_nominalHeader.ipFunction); printf ("\nip.Cmds_[0..19]= "); for(icount = 0; icount < N_IMG_PROC_CMD; icount++) printf (" %02u " ,m_nominalHeader.ipCmd[icount]); /* number of image processing commands */ printf("\nip.ipCmdCnt %02u" ,m_nominalHeader.ipCmdCnt); printf("\nip.ProcessingTime %10u" ,FIX_WORD(m_nominalHeader.ipProcessingTime)); if(FIX_WORD(m_nominalHeader.ipProcessingTime) > 0.00) translateTime( FIX_WORD(m_nominalHeader.ipProcessingTime) ); printf ("\ntime.actualCCDClearStartTime %14.3f" , fix_double(&m_nominalHeader.actualCCDClearStartTime)); if(fix_double(&m_nominalHeader.actualCCDClearStartTime) > 0.00) translateTime( fix_double(&m_nominalHeader.actualCCDClearStartTime )); printf ("\ntime.actualImageRetrieveStartTime %14.3f" , fix_double(&m_nominalHeader.actualImageRetrieveStartTime)); if (fix_double(&m_nominalHeader.actualImageRetrieveStartTime) > 0) translateTime( fix_double(&m_nominalHeader.actualImageRetrieveStartTime )); printf("\n\n"); return(FALSE); } int unpack_ext_sci_hdr() { uint16 idx; printf ("\n cImageHdr::Extended Header----------" ); printf ("\nfps.useFPS %u" ,m_extendedHeader.useFPS); printf ("\nfps.actualFPSMode %u" ,m_extendedHeader.actualFPSMode); printf ("\nfps.actualScFinePointMode %u" ,m_extendedHeader.actualScFinePointMode); printf ("\nmech.cmdQuadPosition %03u" ,m_extendedHeader.cmdQuadPosition); printf ("\nfps.imageNum %u" , FIX_WORD(m_extendedHeader.fpsData.imageNum )); printf ("\nfps.yOffset %u" , FIX_WORD(m_extendedHeader.fpsData.yOffset )); printf (" : zOffset %u" , FIX_WORD(m_extendedHeader.fpsData.zOffset )); printf ("\nfps.numFpsSamples %u" , FIX_WORD(m_extendedHeader.fpsData.numFpsSamples)); printf ("\nfps.fpsYSum % 5u" , FIX_WORD(m_extendedHeader.fpsData.fpsYSum) ); printf (" : fpsZSum % 5u" , FIX_WORD(m_extendedHeader.fpsData.fpsZSum )); printf ("\nfps.fpsYSquare % 5u" , FIX_WORD(m_extendedHeader.fpsData.fpsYSquare )); printf (" : fpsZSquare % 5u" , FIX_WORD(m_extendedHeader.fpsData.fpsZSquare) ); printf ("\n fps.pztErrSum[0..2] % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztErrSum[0]) ); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztErrSum[1]) ); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztErrSum[2]) ); printf ("\nfps.pztErrSquare[0..2] % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztErrSquare[0])); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztErrSquare[1])); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztErrSquare[2])); printf ("\n fps.pztDacSum[0..2] % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztDacSum[0]) ); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztDacSum[1]) ); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztDacSum[2]) ); printf ("\nfps.pztDacSquare[0..2] % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztDacSquare[0])); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztDacSquare[1])); printf (" % 9u" , FIX_WORD(m_extendedHeader.fpsData.pztDacSquare[2])); // Init the structure sGtFpsCoefs for ( idx = 0; idx < 3; idx++ ) { printf ("\nfps.fpsCoefs.pzt[%d]" , idx ); printf ("\n fps.yCoordXform %d", (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].yCoordXform )); printf (" : zCoordXform %d", (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].zCoordXform )); printf ("\n fps.voltPredict[0..4] % 4d", (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].voltPredict[0]) ); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].voltPredict[1]) ); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].voltPredict[2]) ); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].voltPredict[3]) ); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].voltPredict[4]) ); printf ("\n fps.pidCoef[0..3] % 4d", (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].pidCoef[0] )); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].pidCoef[1]) ); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].pidCoef[2]) ); printf (" % 4d" , (int16) SWAP_BYTE(m_extendedHeader.fpsData.fpsCoefs.pzt[idx].pidCoef[3]) ); } printf("\n\n" ); return(FALSE); } /* receive header data */ int receive_hdr(filename) char *filename; { unsigned int byte=0; int fail=FALSE; unsigned short hdr_size=0; unsigned int byte_count=0; FILE *infile; hdr_size = 0 ; if((infile = fopen(filename,"r")) == NULL) { printf("\nCannot open file %s\n",filename); return(TRUE); } printf("Reading Base Header of size %d bytes\n",sizeof(m_baseHeader)); hdr_size = fread(&m_baseHeader,sizeof(m_baseHeader),1,infile); if(hdr_size != 1) { printf("Unable to read Base Header\n"); exit(1); } fail = unpack_base_sci_hdr(); /* FSW 4.7 and older had short headers */ #ifdef VER5 if ( m_baseHeader.eHeaderTypeFlag >= 0 ) #else if ( m_baseHeader.eHeaderTypeFlag > 0 ) #endif { printf("Reading Nominal Header of size %d bytes\n",sizeof(m_nominalHeader)); hdr_size += fread(&m_nominalHeader,sizeof(m_nominalHeader),1,infile); if(hdr_size != 2) { printf("Unable to read Nominal Header\n"); exit(1); } fail = unpack_nom_sci_hdr(); } if ( m_baseHeader.eHeaderTypeFlag > 1 ) { printf("Reading Extended Header of size %d bytes\n",sizeof(m_extendedHeader) ); hdr_size += fread(&m_extendedHeader,sizeof(m_extendedHeader) ,1,infile); if(hdr_size != 3) { printf("Unable to read Extended Header\n"); exit(1); } fail = unpack_ext_sci_hdr(); } fclose(infile); return(fail); } main(argc,argv) int argc; char **argv; { char inchar,filename[80]; int icount=0; if(argc < 2) { printf("Usage: %s filename1 filename2 ...\n",argv[0]); printf("\n%s\n",sccs_string); exit(1); } printf("rdSh Version 5\nVariables reported in Decimal\n"); for(icount = 1; icount < argc; icount++) { strcpy(filename,argv[icount]); printf("Reading %s\n",filename); if(receive_hdr(filename) == TRUE) printf("\nProblem Reading Header\n");; printf("\n\n"); } }