head 3.11; access oasisa; symbols ; locks oasisa:3.11; strict; comment @ * @; 3.11 date 2002.11.05.16.28.06; author oasisa; state Exp; branches ; next 3.10; 3.10 date 2002.11.05.16.23.38; author oasisa; state Exp; branches ; next 3.9; 3.9 date 2002.06.10.14.40.44; author oasisa; state Exp; branches ; next 3.8; 3.8 date 2002.04.23.12.02.02; author oasisa; state Exp; branches ; next 3.7; 3.7 date 2002.03.05.15.35.31; author oasisa; state Exp; branches ; next 3.6; 3.6 date 2002.03.01.15.37.52; author oasisa; state Exp; branches ; next 3.5; 3.5 date 2001.06.19.12.59.40; author oasisa; state Exp; branches ; next 3.4; 3.4 date 2001.05.04.12.58.20; author oasisa; state Exp; branches ; next 3.3; 3.3 date 2001.05.02.10.52.47; author oasisa; state Exp; branches ; next 3.2; 3.2 date 2001.04.25.09.28.37; author oasisa; state Exp; branches ; next 3.1; 3.1 date 2000.08.29.15.39.28; author oasisa; state Exp; branches ; next 3.0; 3.0 date 99.05.12.10.11.30; author bobh; state Exp; branches ; next 2.9; 2.9 date 98.08.24.13.45.58; author bobh; state Exp; branches ; next 2.8; 2.8 date 98.03.17.11.11.45; author bobh; state Exp; branches ; next 1.1; 1.1 date 97.10.27.09.53.19; author bobh; state Exp; branches ; next ; desc @Program to extract data to files from ARGOS data for EqPac moorings @ 3.11 log @fixed return val in printmiscrev4() @ text @/************************************************************************/ /* Copyright 1997 MBARI */ /************************************************************************/ /* $Header: argextract.c,v 3.10 2002/11/05 16:23:38 oasisa Exp $ */ /* Summary : Program to extract data files from ARGOS data */ /* Filename : argextract.c */ /* Author : Bob Herlien (rah) */ /* Project : OASIS */ /* $Revision: 3.10 $ */ /* Created : 13 Jan 1997 from argos.c */ /* */ /* MBARI provides this documentation and code "as is", with no warranty, */ /* express or implied, of its quality or consistency. It is provided without*/ /* support and without obligation on the part of the Monterey Bay Aquarium */ /* Research Institute to assist in its use, correction, modification, or */ /* enhancement. This information should not be published or distributed to */ /* third parties without specific written permission from MBARI. */ /* */ /************************************************************************/ /* Modification History: */ /* 13jan97 rah - created from argos.c */ /* $Log: argextract.c,v $ * Revision 3.10 2002/11/05 16:23:38 16:23:38 oasisa (Oasis users) * fixed bug in battery decoding (getIntellong() declared to return Nat16 instead of Nat32) * * * Revision 3.9 2002/06/10 14:40:44 14:40:44 oasisa (Oasis users) * fix argos mail input for win32 * fix hr3 byte order for unix * * Revision 3.8 2002/04/23 12:02:02 12:02:02 oasisa (Oasis users) * Support for HS2, HR3 * * Revision 3.6 2002/03/01 15:37:52 15:37:52 oasisa (Oasis users) * Support for Local receiver input, WIN32 * * Revision 3.5 2001/06/19 12:59:40 12:59:40 oasisa (Oasis users) * Periodic Update w/ changes to utils * plus new utils 6/19/2001 (klh) * * Revision 3.4 2001/05/04 12:58:20 12:58:20 oasisa (Oasis users) * change bcopy() to memmove() for WIN32 compatibility * * Revision 3.3 2001/05/02 10:52:47 10:52:47 oasisa (Oasis users) * new ISUS format * * Revision 3.2 2001/04/25 09:28:37 09:28:37 oasisa (Oasis users) * HS2 Processing added (klh). * * Revision 3.0 99/05/12 10:11:30 10:11:30 bobh (Bob Herlien) * Added tstring, misc changes * * Revision 2.9 98/08/24 13:45:58 13:45:58 bobh (Bob Herlien) * Archiving sources after M2/M3 & Eqpac deployments of 1998 * * Revision 2.8 98/03/17 11:11:45 11:11:45 bobh (Bob Herlien) * Archiving sources prior to porting to DOS/Windows * * Revision 1.1 97/10/27 09:53:19 09:53:19 bobh (Bob Herlien) * Initial revision * */ /************************************************************************/ #include /* Unix standard I/O */ #include /* Unix standard library */ #include /* MBARI standard types */ #include /* MBARI standard constants */ #include /* Unix time library */ #include /* OASIS data definitions */ #include /* Unix string library */ #include /* ARGOS buffer definitions */ #define SPEC_VOLTS FALSE #define NUM_MSGS 100 /* Max messages to store & compare */ #define BUFSIZE 1024 /* Line buffer size */ #define FLUOR_CHAN 0 /* Analog channel for Wetstar fluor*/ #define TEMP_CHAN 2 /* Analog channel for temperature */ #define OBATT_CHAN 3 /* Analog channel for OASIS battery*/ #define ABATT_CHAN 6 /* Analog channel for ARGOS battery*/ #define YEAR0 70 #define MAX_PTTS 8 #define CHEM_TIME(i) ((Flt64)(i)/(8.0*365.0)) typedef enum /********************************/ { /* Return value from getXXXMsg */ MSG_OK, /* Successful conversion */ BAD_MSG, /* Bad message data */ END_OF_FILE /* End of input file */ } MsgRtn; /********************************/ typedef enum /********************************/ { /* Type of input */ SVC_ARGOS=0, /* From Serivce Argos */ RCVR_NORM, /* From local receiver, normal mode*/ RCVR_DIAG, /* Local receiver, diagnostic mode*/ ALPHA_OMEGA /* Alpha-Omega receiver */ } InputMode; /********************************/ /********************************/ /* External Functions */ /********************************/ Extern char *get_can_name( char *dataname ); Extern Status read_cfg( char **cfgname ); Extern double decode_prr_chan( Int16 ival, SpecChanCal *sccp ); Extern Flt64 decode_ac9_temp( Int32 count ); Extern Void print_sensor( Int sensor, char *fmt, ... ); Extern Void print_error( char *fmt, ... ); Extern Void close_sensor_files( Void ); #ifdef WIN32 Extern Int getopt( Int argc, char **argv, char *fmt ); #endif Extern Nat16 getIntelword( Byte *p ); Extern Nat32 getIntellong( Byte *p ); /********************************/ /* External Data */ /********************************/ Extern char *optarg; /* Option argument from getopt() */ Extern Int optind; /* Option index from getopt() */ Extern Analog analog[ANALOG_CHANS]; /* Analog calibration */ Extern SpecCal spec_cal; /* Struct to hold Spect calibrations*/ Extern Int32 gmt_offset; /* GMT offset in hours */ Extern Nat32 temp_offset; /* Offset for NO3 temperatures */ Extern MBool smallConfig; /* TRUE for small PTT data config */ Extern MBool reverseNO3; /* TRUE to reverse 0m & 20m NO3s */ Extern Int32 revision; /* Software & msg type revision nmbr*/ Extern double dfiletime; /* file time for dated cal files */ /********************************/ /* Module Local Data */ /********************************/ #ifdef WIN32 MLocal InputMode inputMode = RCVR_DIAG; #else MLocal InputMode inputMode = SVC_ARGOS; #endif MLocal char *cfgp = NULL; /* Ptr to name of OASIS config file */ MLocal MBool decode_all = TRUE; MLocal MBool decode_msg[NUM_MSG_TYPES]; MLocal MBool decode_all_ptt=TRUE; MLocal Nat32 ptt_count=0; MLocal Nat32 decode_ptt[MAX_PTTS]; MLocal Nat32 numMsgs = 0; MLocal Nat32 msgCnt = 0; MLocal char buffer[BUFSIZE]; MLocal ArgosInMsg msgs[NUM_MSGS]; MLocal Int32 msgTypesRev1[] = { CHEM, SPEC_0M_NOON, SPEC_0M_AM, SPEC_20M, AC9_1, AC9_2, MISC }; MLocal Nat32 mType; /********************************/ /* Forward Declarations */ /********************************/ MBool processCommandLine ( Int32 argc, char **argv ); Void decodeFile( char *filename ); Void printOneMsg( ArgosInMsg *msgp ); Void printIsus(Nat32 filenum, Flt64 day, void *msgp); Void printHS2(Nat32 filenum, Flt64 day, void *msgp); /************************************************************************/ /* Function : main */ /* Purpose : Main routine */ /* Inputs : argc, argv */ /* Outputs : Integer, 0 for success, 1 for failure */ /************************************************************************/ Int32 main( Int32 argc, char **argv ) { char *filename, *cp; Reg Int32 i; if ( !processCommandLine(argc, argv) ) exit( 1 ); putenv( "TZ=GMT0" ); for ( i = optind; i < argc; i++ ) { filename = argv[i]; get_can_name( filename ); cp = cfgp; if ( read_cfg(&cp) != OK ) printf("Can't read configuration file \"%s\"\n", cp); else decodeFile( filename ); } return (0); } /* main() */ /************************************************************************/ /* Function : use_msg */ /* Purpose : Print Usage Message */ /* Inputs : Name of program */ /* Outputs : None */ /************************************************************************/ Void use_msg( char *s ) { fprintf( stderr, "Usage: %s [-c cfg_file] [-i msg_number]\n",s ); fprintf( stderr, "-a is for an Alpha-Omega receiver\n" ); fprintf( stderr, "-c specifies a configuration file\n" ); fprintf( stderr, "-d is for a Telonics receiver in diagnostic mode\n" ); fprintf( stderr, "-e is for a email received from Service Argos\n" ); fprintf( stderr, "-D specifies data file time for dated config file (yyyyjjj.hh)\n" ); fprintf( stderr, "-i decodes a specified message number\n" ); fprintf( stderr, "-n is for a Telonics receiver in normal mode\n" ); fprintf( stderr, "-p decodes a specified PTT number\n"); fprintf( stderr, "default is for data from Service Argos\n"); } /* use_msg() */ /************************************************************************/ /* Function : processCommandLine */ /* Purpose : Read the arguments from the command line */ /* Inputs : argc, argv from main() routine */ /* Outputs : TRUE if arguments OK, else FALSE */ /************************************************************************/ MBool processCommandLine ( Int32 argc, char **argv ) { Int32 c, i; dfiletime= (-1.0);/* set filetime < 0 (get time from filename by default) */ for ( i = 0; i < NUM_MSG_TYPES; i++ ) decode_msg[i] = FALSE; while ( (c = getopt(argc, argv, "adenc:D:i:p:")) != EOF ){ switch( c ) { case 'a': inputMode = ALPHA_OMEGA; break; case 'c': cfgp = optarg; break; case 'd': inputMode = RCVR_DIAG; break; case 'D': if(sscanf(optarg,"%lg",&dfiletime)<1) dfiletime = (-1.0); else if(dfiletime<100000) dfiletime+=1900000; break; case 'e': inputMode = SVC_ARGOS; break; case 'i': decode_all = FALSE; decode_msg[atoi(optarg)] = TRUE; break; case 'n': inputMode = RCVR_NORM; break; case 'p': decode_all_ptt=FALSE; if(ptt_count<=MAX_PTTS) decode_ptt[ptt_count++] = atoi(optarg); break; default: use_msg( argv[0] ); return( FALSE ); }/* end switch*/ }/* end while */ return( TRUE ); } /* processCommandLine() */ /************************************************************************/ /* Function : getLine */ /* Purpose : Get one line of ARGOS message */ /* Inputs : FILE pointer, buffer ptr */ /* Outputs : MSG_OK or END_OF_FILE */ /************************************************************************/ MsgRtn getLine( FILE *fp, char * buffer ) { Reg Int32 len; char *cp; buffer[0] = '\0'; while( TRUE ) { if ( (cp=fgets(buffer, BUFSIZE, fp)) == NULL ){ return( END_OF_FILE ); } if ( (len = strlen(buffer)) > 0 ) { if ( buffer[len] == '\n' ) buffer[len] = '\0'; return( MSG_OK ); }else{ return(END_OF_FILE); } }/* end while */ } /* getLine() */ /************************************************************************/ /* Function : getSvcArgosMsg */ /* Purpose : Get an ARGOS message in Service Argos format */ /* Inputs : FILE ptr, Buffer ptr, message ptr, time ptr, number of msgs*/ /* Outputs : Message return code */ /************************************************************************/ MsgRtn getSvcArgosMsg( FILE *fp, char *buffer, WordMsg *msgp, struct tm *tmPtr, Int32 *nmsgs ) { Nat32 i, j, dat[4]; if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %d-%d-%d %d:%d:%d %d %x %x %x %x", &tmPtr->tm_year, &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec, nmsgs, &dat[0], &dat[1], &dat[2], &dat[3]) < 11 ) return( BAD_MSG ); tmPtr->tm_year -= 1900; tmPtr->tm_mon -= 1; for ( i = 0; i < 4; i++ ) msgp->wd_data[i] = (Nat16)dat[i]; for ( i = 4; i < ARGOS_WORDS; i += 4 ) { if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %x %x %x %x", &dat[0], &dat[1], &dat[2], &dat[3]) < 4 ) return( BAD_MSG ); for ( j = 0; j < 4; j++ ) msgp->wd_data[i + j] = (Nat16)dat[j]; } return( MSG_OK ); } /* getSvcArgosMsg() */ /************************************************************************/ /* Function : getNormalMsg */ /* Purpose : Get an ARGOS message in normal format for local rcvr */ /* Inputs : FILE ptr, Buffer ptr, message ptr for return message */ /* Outputs : Message return code */ /************************************************************************/ MsgRtn getNormalMsg( FILE *fp, char *buffer, ByteMsg *msgp, struct tm *tmPtr ) { Nat32 i, j, dat[8]; Nat32 ptt; MBool isValidPTT=FALSE; if ( getLine(fp, buffer) == END_OF_FILE ){ return( END_OF_FILE ); } if ( sscanf(buffer, " %d-%d-%d %d:%d:%d ID %d", &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_year, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec,&ptt) < 7 ){ return( BAD_MSG ); } if(!decode_all_ptt){ for(i=0;itm_mon -= 1; if ( tmPtr->tm_year < YEAR0 ) tmPtr->tm_year += 100; /* Y2k fix 4/16/2001 klh*/ for ( i = 0; i < ARGOS_LEN; i += 8 ) { if ( getLine(fp, buffer) == END_OF_FILE ){ return( END_OF_FILE ); } if ( sscanf(buffer, " %d %d %d %d %d %d %d %d", &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5], &dat[6], &dat[7]) < 8 ){ return( BAD_MSG ); } for ( j = 0; j < 8; j++ ) msgp->by_data[i + j] = (Byte)dat[j]; } return( MSG_OK ); } /* getNormalMsg() */ /************************************************************************/ /* Function : getDiagnosticMsg */ /* Purpose : Get an ARGOS message in diagnostic format for local rcvr*/ /* Inputs : FILE ptr, Buffer ptr, message ptr for return message */ /* Outputs : Message return code */ /************************************************************************/ MsgRtn getDiagnosticMsg( FILE *fp, char *buffer, ByteMsg *msgp, struct tm *tmPtr ) { Nat32 i, j, dat[8]; Nat32 ptt; MBool isValidPTT=FALSE; if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %d-%d-%d %d:%d:%d ID %d", &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_year, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec, &ptt) < 7 ) return( BAD_MSG ); if(!decode_all_ptt){ for(i=0;itm_mon -= 1; if ( tmPtr->tm_year < YEAR0 ) tmPtr->tm_year += 100; /* Y2k fix 5/22/2000 rah*/ if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %*x %*x %*x %*x %*x %*x %x %x", &dat[0], &dat[1]) < 2) return( BAD_MSG ); msgp->by_data[0] = (Byte)dat[0]; msgp->by_data[1] = (Byte)dat[1]; for ( i = 2; i < ARGOS_LEN - 6; i += 8 ) { if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %x %x %x %x %x %x %x %x", &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5], &dat[6], &dat[7]) < 8 ) return( BAD_MSG ); for ( j = 0; j < 8; j++ ) msgp->by_data[i + j] = (Byte)dat[j]; } if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %x %x %x %x %x %x", &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5]) < 6 ) return( BAD_MSG ); for ( j = 0; j < 6; j++ ) msgp->by_data[i + j] = (Byte)dat[j]; /*getLine( fp, buffer );*/ return( MSG_OK ); } /* getDiagnosticMsg() */ /************************************************************************/ /* Function : getAlphaOmegaMsg */ /* Purpose : Get an ARGOS message in Alpha-Omega Receiver format */ /* Inputs : FILE ptr, Buffer ptr, message ptr for return message */ /* Outputs : Message return code */ /* Comment : Assumes A-O rcvr in byte format, which is not default */ /************************************************************************/ MsgRtn getAlphaOmegaMsg( FILE *fp, char *buffer, ByteMsg *msgp, struct tm *tmPtr ) { Nat32 pttNum, i, dat[32]; MBool isValidPTT=FALSE; if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %d/%d/%d %d:%d:%d %d %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_year, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec, &pttNum, &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5], &dat[6], &dat[7], &dat[8], &dat[9], &dat[10], &dat[11], &dat[12], &dat[13], &dat[14], &dat[15], &dat[16], &dat[17], &dat[18], &dat[19], &dat[20], &dat[21], &dat[22], &dat[23], &dat[24], &dat[25], &dat[26], &dat[27], &dat[28], &dat[29], &dat[30], &dat[31]) < 39 ) return( BAD_MSG ); if(!decode_all_ptt){ for(i=0;itm_year -= 1900; tmPtr->tm_mon -= 1; for ( i = 0; i < 32; i++ ) msgp->by_data[i] = (Byte)dat[i]; return( MSG_OK ); } /* getAlhpaOmegaMsg() */ /************************************************************************/ /* Function : msgMatch */ /* Purpose : See if two ARGOS messages are the same */ /* Inputs : Two Message ptrs */ /* Outputs : TRUE if match, else FALSE */ /************************************************************************/ MBool msgMatch( ByteMsg *msgp1, ByteMsg *msgp2 ) { Int32 i; for ( i = 0; i < ARGOS_LEN; i++ ) if ( msgp1->by_data[i] != msgp2->by_data[i] ) return( FALSE ); return( TRUE ); } /* msgMatch() */ /************************************************************************/ /* Function : findMatchingMessage */ /* Purpose : Find a matching ARGOS message from those already received*/ /* Inputs : Message ptr */ /* Outputs : Message number of matching message, or ERROR */ /************************************************************************/ Int32 findMatchingMessage( ByteMsg *msgp ) { Nat32 i; for ( i = 0; i < msgCnt; i++ ) if ( msgMatch(msgp, &msgs[i].msg.rawb) ) return( i ); return( ERROR ); } /* findMatchingMessage() */ /************************************************************************/ /* Function : getMessages */ /* Purpose : Get all incoming ARGOS messages */ /* Inputs : FILE pointer */ /* Outputs : None */ /************************************************************************/ Void getMessages( FILE *fp, char *buffer ) { struct tm msgTime, *tmPtr; time_t msg_time_t; MsgRtn state; ArgosUnion msg; Int32 msgNum, nmsgs; numMsgs = msgCnt = 0; bzero( (void *)msgs, sizeof(msgs) ); time( &msg_time_t ); tmPtr = gmtime( &msg_time_t ); memcpy( (void *)&msgTime, (void *)tmPtr, sizeof(struct tm) ); msgTime.tm_isdst = 0; state = MSG_OK; while ( state != END_OF_FILE ) { nmsgs = 1; switch( inputMode ) { case SVC_ARGOS: state = getSvcArgosMsg( fp, buffer, &msg.raww, &msgTime, &nmsgs ); break; case RCVR_NORM: state = getNormalMsg( fp, buffer, &msg.rawb, &msgTime ); break; case RCVR_DIAG: state = getDiagnosticMsg( fp, buffer, &msg.rawb, &msgTime ); break; case ALPHA_OMEGA: state = getAlphaOmegaMsg( fp, buffer, &msg.rawb, &msgTime ); break; default: return; } /*state = getSvcArgosMsg( fp, buffer, &msg.raww, &msgTime, &nmsgs );*/ if ( state == MSG_OK ) { msg_time_t = mktime( &msgTime ); if ( (msgNum = findMatchingMessage(&msg.rawb)) != ERROR ) { if ( msg_time_t < msgs[msgNum].first_msg ) msgs[msgNum].first_msg = msg_time_t; if ( msg_time_t > msgs[msgNum].last_msg ) msgs[msgNum].last_msg = msg_time_t; msgs[msgNum].msg_cnt += nmsgs; } else { if ( msgCnt >= NUM_MSGS ) { printOneMsg( &msgs[0] ); memmove( (void *)msgs, (void *)&msgs[1], (NUM_MSGS - 1) * sizeof(ArgosInMsg) ); msgCnt--; } msgs[msgCnt].first_msg = msg_time_t; msgs[msgCnt].last_msg = msg_time_t; msgs[msgCnt].msg_cnt = nmsgs; memcpy( (void *)&msgs[msgCnt].msg.rawb, (void *)&msg, sizeof(ArgosUnion) ); numMsgs += nmsgs; msgCnt++; } }/* end if MSG_OK */ }/* end while */ } /* getMessages() */ /************************************************************************/ /* Function : fileDate */ /* Purpose : Convert Unix time_t to file date spec */ /* Inputs : Time of first ARGOS hit */ /* Outputs : Decimal year, e.g. 97.003 for Jan 2, 1997 */ /************************************************************************/ Flt64 fileDate( time_t timeToConvert ) { time_t adjustedTime; struct tm *tmPtr; Int32 year; Flt64 daysPerYear; adjustedTime = timeToConvert + (3600 * gmt_offset) - (24 * 3600); tmPtr = gmtime( &adjustedTime ); /* year = tmPtr->tm_year + 1900;*/ year = tmPtr->tm_year; daysPerYear = ((year % 4) == 0) ? 366.0 : 365.0; return( (Flt64)year + ((Flt64)tmPtr->tm_yday / daysPerYear) ); } /* fileDate() */ /************************************************************************/ /* Function : printChem */ /* Purpose : Print data from Chem message */ /* Inputs : File day, Chem message ptr */ /* Outputs : None */ /************************************************************************/ Void printChem( Flt64 day, ChemMsg *msgp ) { Nat32 i, msbs; Int32 co2; msbs = getIntelword( (Byte *)&msgp->ch_pco2_msbs ); for ( i = 0; i < CHEM_SAMPLES; i++ ) { co2 = msgp->ch_pco2[i] | (((msbs >> (i + i)) & 3) << 8); if ( co2 & 0x200 ) co2 |= ~0x3ff; /* Sign extend */ print_sensor( CO2_FILE, "%8.4f %4d\n", day + CHEM_TIME(i), co2 ); } } /* printChem() */ /************************************************************************/ /* Function : printChem4 */ /* Purpose : Print data from Chem message (rev 4 format) */ /* Inputs : File day, Chem message ptr */ /* Outputs : None */ /************************************************************************/ Void printChem4( Flt64 day, Chem4Msg *msgp ) { Reg Byte *p; Int32 co2; Nat16 ipitch, iroll, itemp, idepth; Nat32 i; p = msgp->ch_pco2; for ( i = 0; i < CHEM_SAMPLES; i+=2 ) { co2 = *p++ << 4; co2 |= ((*p >> 4) & 0x0f); if ( co2 & 0x800 ) co2 |= 0xfffff000; /* Sign extend */ print_sensor( CO2_FILE, "%8.4f %4d\n", day + CHEM_TIME(i), co2 ); co2 = ((*p++ & 0x0f) << 8); co2 |= *p++; if ( co2 & 0x800 ) co2 |= 0xfffff000; /* Sign extend */ print_sensor( CO2_FILE, "%8.4f %4d\n", day + CHEM_TIME(i+1), co2 ); } ipitch = getIntelword( (Byte *)&msgp->ch_prr_pitch ); iroll = getIntelword( (Byte *)&msgp->ch_prr_roll ); itemp = getIntelword( (Byte *)&msgp->ch_prr_temp ); idepth = getIntelword( (Byte *)&msgp->ch_prr_depth ); print_sensor( SPEC_MISC_FILE, "%8.4f %6.1f %6.1f %7.2f %7.2f", day, decode_prr_chan(ipitch, &spec_cal.spc_cal[0][10]), decode_prr_chan(iroll, &spec_cal.spc_cal[0][11]), decode_prr_chan(itemp, &spec_cal.spc_cal[2][8]), decode_prr_chan(idepth, &spec_cal.spc_cal[2][9]) ); ipitch = getIntelword( (Byte *)&msgp->ch_prr_pitch1230 ); iroll = getIntelword( (Byte *)&msgp->ch_prr_roll1230 ); itemp = getIntelword( (Byte *)&msgp->ch_prr_temp1230 ); idepth = getIntelword( (Byte *)&msgp->ch_prr_depth1230 ); print_sensor( SPEC_MISC_FILE, " %6.1f %6.1f %7.2f %7.2f\n", decode_prr_chan(ipitch, &spec_cal.spc_cal[0][10]), decode_prr_chan(iroll, &spec_cal.spc_cal[0][11]), decode_prr_chan(itemp, &spec_cal.spc_cal[2][8]), decode_prr_chan(idepth, &spec_cal.spc_cal[2][9]) ); } /* printChem4() */ /************************************************************************/ /* Function : printChemR5 */ /* Purpose : Print data from Chem message (rev 5 fmt) */ /* Inputs : File day, Chem message ptr */ /* Outputs : None */ /************************************************************************/ Void printChemR5( Flt64 day, Chem5Msg *msgp ) { Reg Byte *p; Int32 co2; Nat16 itemp, idepth; Nat32 i; p = msgp->ch_pco2; for ( i = 0; i < CHEM_SAMPLES; i+=2 ) { co2 = *p++ << 4; co2 |= ((*p >> 4) & 0x0f); if ( co2 & 0x800 ) co2 |= 0xfffff000; /* Sign extend */ print_sensor( CO2_FILE, "%8.4f %4d\n", day + CHEM_TIME(i), co2 ); co2 = ((*p++ & 0x0f) << 8); co2 |= *p++; if ( co2 & 0x800 ) co2 |= 0xfffff000; /* Sign extend */ print_sensor( CO2_FILE, "%8.4f %4d\n", day + CHEM_TIME(i+1), co2 ); } itemp = getIntelword( (Byte *)&msgp->ch_prr_temp ); idepth = getIntelword( (Byte *)&msgp->ch_prr_depth ); print_sensor( SPEC_MISC_FILE, "%8.4f %7.2f %7.2f\n", day, decode_prr_chan(itemp, &spec_cal.spc_cal[2][8]), decode_prr_chan(idepth, &spec_cal.spc_cal[2][9]) ); printIsus( ISUS_FILE,day,(void *)msgp ); } /* printChemR5() */ /************************************************************************/ /* Function : printNO3 */ /* Purpose : Print an NO3 buffer */ /* Inputs : File number, file day, NO3 msg ptr */ /* Outputs : None */ /************************************************************************/ Void printNO3( Nat32 filenum, Flt64 day, No3Msg *no3p ) { Reg Nat32 i, no3; Reg Byte *p; p = no3p->no3; for ( i = 0; i < CHEM_SAMPLES; ) { no3 = *p++ << 4; no3 |= ((*p >> 4) & 0x0f); print_sensor( filenum, "%8.4f %4d\n", day + CHEM_TIME(i), no3 ); i++; no3 = ((*p++ & 0x0f) << 8); no3 |= *p++; print_sensor( filenum, "%8.4f %4d\n", day + CHEM_TIME(i), no3 ); i++; } } /* printNO3() */ /************************************************************************/ /* Function : printTemp */ /* Purpose : Print Temperature from NO3 */ /* Inputs : File number, file day, NO3 msg ptr */ /* Outputs : None */ /************************************************************************/ Void printTemp( Nat32 filenum, Flt64 day, No3Msg *no3p ) { Reg Nat32 i; for ( i = 0; i < CHEM_SAMPLES; i++ ) print_sensor( filenum, "%8.4f %5.2f\n", day + CHEM_TIME(i), (Flt64)((Nat32)(no3p->temp[i]) + temp_offset)/20.0); } /* printTemp() */ /************************************************************************/ /* Function : printIsus */ /* Purpose : Print ISUS data (stored in sp_lu[] of SpecMsg) */ /* Inputs : ? */ /* Outputs : None */ /************************************************************************/ Void printIsus(Nat32 filenum, Flt64 day, void *msgp) { Nat16 i; unsigned char w[2]; print_sensor(filenum,"%8.4f ",day); if (mType == SPEC_0M_1000){ for(i=0;i<(ASPEC_CHANS);i++){ memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[i],2); /*print_sensor(filenum,"%0.2x %0.2x ",w[0],w[1]);*/ if(w[0] < 0x20 || w[0] >= 0x7f) print_sensor(filenum,"\\x%02x",w[0]&0x0f); else print_sensor(filenum,"%c",w[0]); if(w[1] < 0x20 || w[1] >= 0x7f) print_sensor(filenum,"\\x%02x",w[1]&0x0f); else print_sensor(filenum,"%c",w[1]); } print_sensor(filenum," S"); }else{ if (mType == CHEM){ for(i=0;i<(CH_UNUSED_SIZE);i++){ memmove((Byte *)&w[0],(Byte *)&((Chem5Msg *)msgp)->ch_unused[i],2); /*print_sensor(filenum,"%0.2x %0.2x ",w[0],w[1]);*/ if(w[0] < 0x20 || w[0] >= 0x7f) print_sensor(filenum,"\\x%0.2x",w[0]&0x0f); else print_sensor(filenum,"%c",w[0]); if(w[1] < 0x20 || w[1] >= 0x7f) print_sensor(filenum,"\\x%02x",w[1]&0x0f); else print_sensor(filenum,"%c",w[1]); } print_sensor(filenum," C"); } } print_sensor(filenum,"\n"); return; }/*printIsus()*/ /************************************************************************/ /* Function : printHS2 */ /* Purpose : Print Hobi HS2 data (stored in sp_lu[] of SAT1Msg) */ /* Inputs : ? */ /* Outputs : None */ /************************************************************************/ Void printHS2(Nat32 filenum, Flt64 day, void *msgp) { char w[2]; print_sensor(filenum,"%8.4f",day); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[0],2); print_sensor(filenum," %02X%02X ",w[0]&0xFF,w[1]&0xFF);/* Snorm1 */ memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[1],2); print_sensor(filenum," %02X%02X ",w[0]&0xFF,w[1]&0xFF);/* Snorm2 */ memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[2],2); print_sensor(filenum," %02X%02X",w[0]&0xFF,w[1]&0xFF);/* Snorm3 */ memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[3],2); print_sensor(filenum," %01X %01X %01X",(w[0]>>4)&0x0F,w[0]&0x0F,(w[1]>>4)&0x0F);/* Gain 1-3 */ memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[4],1); print_sensor(filenum," %01X",w[0]&0xFF);/* TempRaw */ print_sensor(filenum,"\n"); return; }/*printHS2()*/ /************************************************************************/ /* Function : printHR3 */ /* Purpose : Print Hobi HR3 data (stored in sp_lu[] of SAT1Msg) */ /* Inputs : ? */ /* Outputs : None */ /************************************************************************/ Void printHR3(Nat32 filenum, Flt64 day, void *msgp) { char w[2]; print_sensor(filenum,"%8.4f",day); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[0],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[1],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[2],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[3],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[4],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[5],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[6],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); print_sensor(filenum,"\n"); return; }/*printHR3()*/ /************************************************************************/ /* Function : printSpec */ /* Purpose : Print a PRR Spectro message */ /* Inputs : File number, File day, Spectro message ptr, */ /* Address tags for Ed, Lu chans */ /* Outputs : None */ /************************************************************************/ Void printSpec( Nat32 filenum, Flt64 day, SpecMsg *msgp, Int32 edAdr, Int32 luAdr, Int32 edChan, Int32 luChan ) { Reg Int32 i; Reg Nat16 ival; Flt64 ed, lu; print_sensor( filenum, "%8.4f ", day ); for ( i = 0; i < ASPEC_CHANS; i++ ) { ival = getIntelword( (Byte *)&msgp->sp_ed[i] ); #if SPEC_VOLTS ed = decode_prr_chan( ival, NULL ); #else ed = decode_prr_chan( ival, &spec_cal.spc_cal[edAdr][i+edChan] ); #endif print_sensor( filenum, "%9.5f ", ed ); } for ( i = 0; i < ASPEC_CHANS; i++ ) { ival = getIntelword( (Byte *)&msgp->sp_lu[i] ); #if SPEC_VOLTS lu = decode_prr_chan( ival, NULL ); #else lu = decode_prr_chan( ival, &spec_cal.spc_cal[luAdr][i+luChan] ); #endif print_sensor( filenum, "%9.5f ", lu ); } } /* printSpec() */ /************************************************************************/ /* Function : printSpecR5 */ /* Purpose : Print a PRR Spectro message rev 5 format */ /* Inputs : File number, File day, Spectro message ptr, */ /* Address tags for Ed, Lu chans */ /* Outputs : None */ /************************************************************************/ Void printSpecR5( Nat32 filenum, Flt64 day, SpecMsg *msgp, Int32 edAdr, Int32 luAdr, Int32 edChan, Int32 luChan ) { Reg Int32 i; Reg Nat16 ival; Flt64 ed, lu; print_sensor( filenum, "%8.4f ", day ); /* Print Ed values */ for ( i = 0; i < ASPEC_CHANS; i++ ) { ival = getIntelword( (Byte *)&msgp->sp_ed[i] ); #if SPEC_VOLTS ed = decode_prr_chan( ival, NULL ); #else ed = decode_prr_chan( ival, &spec_cal.spc_cal[edAdr][i+edChan] ); #endif print_sensor( filenum, "%9.5f ", ed ); } /* Lu contents vary by buffer */ if (mType == SPEC_0M_1000) { printIsus( ISUS_FILE, day, (void *)msgp ); /* Lu holds ISUS */ }else /*if( filenum == SAT1_FILE )*/ if ( mType == SAT1 ) { printHS2(HS2_FILE,day,(void *)msgp);/*Lu holds HS2*/ }else { for ( i = 0; i < ASPEC_CHANS; i++ ) { ival = getIntelword( (Byte *)&msgp->sp_lu[i] ); #if SPEC_VOLTS lu = decode_prr_chan( ival, NULL ); #else lu = decode_prr_chan( ival, &spec_cal.spc_cal[luAdr][i+luChan] ); #endif print_sensor( filenum, "%9.5f ", lu ); } } } /* printSpecR5() */ /************************************************************************/ /* Function : printSpecR6 */ /* Purpose : Print a PRR Spectro message rev 6 format */ /* NOTE: Only for extracting HR data from selected messages */ /* Inputs : File day, Spectro message ptr */ /* Outputs : None */ /************************************************************************/ Void printSpecR6( Flt64 day, SpecMsg *msgp ) { /* Reg Int32 i; Reg Flt32 *pEd,*pLu; if(mType == SPEC_0M_DARK){ pEd = (Flt32 *) &msgp->sp_ed[0]; pLu = (Flt32 *) &msgp->sp_lu[0]; for ( i = 0; i < 3; i++ ) { print_sensor( HR3_FILE, "%8.4f %d 443 %9.4f\n", day, i, *(pEd+i) ); print_sensor( HR3_FILE, "%8.4f %d 490 %9.4f\n", day, i, *(pLu+i) ); } }else if(mType == SPEC_20M_DARK){ pEd = (Flt32 *) &msgp->sp_ed[0]; pLu = (Flt32 *) &msgp->sp_lu[0]; for ( i = 0; i < 3; i++ ) { print_sensor( HR3_FILE, "%8.4f %d 510 %9.4f\n", day, i, *(pEd+i) ); print_sensor( HR3_FILE, "%8.4f %d 555 %9.4f\n", day, i, *(pLu+i) ); } } */ Reg Int32 i; Nat32 *pNEd,*pNLu; Nat32 j,k,pixels[2][3]; Byte *pIn[2], *pOut[2]; Flt32 *pFloat[2]; pNEd = (Nat32 *) &msgp->sp_ed[0]; pNLu = (Nat32 *) &msgp->sp_lu[0]; for ( i = 0; i < 3; i++ ) { pixels[0][i]=0; pixels[1][i]=0; pIn[0] = (Byte *)&pNEd[i]; pOut[0] = (Byte *)&pixels[0][i]; pIn[1] = (Byte *)&pNLu[i]; pOut[1] = (Byte *)&pixels[1][i]; #ifdef WIN32 /* swap byte order for WIN32 */ for(j=0,k=3;j<4;j++,k--){ *(pOut[0]+j) = *(pIn[0]+k); *(pOut[1]+j) = *(pIn[1]+k); } #else for(j=0,k=0;j<4;j++,k++){ *(pOut[0]+j) = *(pIn[0]+k); *(pOut[1]+j) = *(pIn[1]+k); } #endif pFloat[0] = (Flt32 *)&pixels[0][i]; pFloat[1] = (Flt32 *)&pixels[1][i]; switch(mType){ case SPEC_0M_DARK: /* //printf( "\t%d 443 %f\n", i , *pFloat[0] ); //printf( "\t%d 490 %f\n", i , *pFloat[1] ); */ print_sensor( HR3_FILE, "%8.4f %d 443 %9.4f\n", day, i, *pFloat[0] ); print_sensor( HR3_FILE, "%8.4f %d 490 %9.4f\n", day, i, *pFloat[1] ); break; case SPEC_20M_DARK: /* //printf( "\t%d 510 %f\n", i , *pFloat[0] ); //printf( "\t%d 555 %f\n", i , *pFloat[1] ); */ print_sensor( HR3_FILE, "%8.4f %d 510 %9.4f\n", day, i, *pFloat[0] ); print_sensor( HR3_FILE, "%8.4f %d 555 %9.4f\n", day, i, *pFloat[1] ); break; default: break; }/*end switch*/ }/* end for i*/ return; } /* printSpecR6() */ /************************************************************************/ /* Function : printAc9First */ /* Purpose : Print First AC-9 message buffer */ /* Inputs : File day, AC-9.1 message ptr */ /* Outputs : None */ /************************************************************************/ Void printAc9First( Flt64 day, Ac9Msg *ac9p ) { Reg Int32 i; Flt64 ac9; print_sensor( AC9_1_FILE, "%8.4f ", day ); for ( i = 0; i < AC9_1_CHANS; i++ ) { ac9 = (Flt64)(getIntelword((Byte *)&ac9p->ac_data[i])) / 1000.0; print_sensor( AC9_1_FILE, "%9.5f ", ac9 ); } print_sensor( AC9_1_FILE, "\n" ); } /* printAc9First() */ /************************************************************************/ /* Function : printAc9Second */ /* Purpose : Print Second AC-9 message buffer */ /* Inputs : File day, AC-9.2 message ptr */ /* Outputs : None */ /************************************************************************/ Void printAc9Second( Flt64 day, Ac92Msg *ac9p ) { Reg Int32 i; Flt64 ac9, temp, chl, flow; Nat16 pump; print_sensor( AC9_2_FILE, "%8.4f ", day ); for ( i = 0; i < AC9_2_CHANS; i++ ) { ac9 = (Flt64)(getIntelword((Byte *)&ac9p->ac_data[i])) / 1000.0; print_sensor( AC9_2_FILE, "%9.5f ", ac9 ); } temp = decode_ac9_temp( getIntelword((Byte *)&ac9p->ac_temp) ); print_sensor( AC9_2_FILE, "%9.5f ", temp ); for ( i = 0; i < CHEM_SAMPLES; i++ ) { chl = (Flt64)(getIntelword((Byte *)&ac9p->ac_chl[i])) / 1000.0; print_sensor( AC9_2_FILE, "%9.5f ", chl ); } pump = getIntelword( (Byte *)&ac9p->ac_pump ); flow = ((analog[FLOW_CHAN].a * (Flt64)(pump)) + analog[FLOW_CHAN].b) * analog[FLOW_CHAN].c; print_sensor( AC9_2_FILE, "%9.5f %d\n", flow, pump ); } /* printAc9Second() */ /************************************************************************/ /* Function : printMisc */ /* Purpose : Print Miscellaneous message buffer */ /* Inputs : File day, Misc msg ptr */ /* Outputs : None */ /************************************************************************/ Void printMisc( Flt64 day, MiscMsg *msgp ) { Nat32 val; Int32 co2; Flt64 flt1, flt2, flt3; val = getIntelword( (Byte *)&msgp->ms_pco2 ); co2 = val & 0x3ff; if ( co2 & 0x200 ) co2 |= ~0x3ff; /* Sign extend */ print_sensor( CO2_CAL_FILE, "%8.4f %3d %02d00\n", day, co2, ((val >> 10) & 7) * 3 ); val = getIntellong( (Byte *)&msgp->ms_oasis ); flt1 = (((analog[TEMP_CHAN].a * (Flt32)(val & 0x3ff)) + analog[TEMP_CHAN].b) * analog[TEMP_CHAN].c) + analog[TEMP_CHAN].d; flt2 = ((analog[OBATT_CHAN].a * (Flt32)((val >> 10) & 0x3ff)) + analog[OBATT_CHAN].b) * analog[OBATT_CHAN].c; flt3 = ((analog[ABATT_CHAN].a * (Flt32)((val >> 20) & 0x3ff)) + analog[ABATT_CHAN].b) * analog[ABATT_CHAN].c; print_sensor( OASIS_FILE, "%8.4f %5.2f %8.2f %8.2f\n", day, flt1, flt2, flt3 ); if ( !smallConfig ) { #if SPEC_VOLTS flt1 = decode_prr_chan( getIntelword((Byte *)&msgp->ms_mcp10), NULL ); flt2 = decode_prr_chan( getIntelword((Byte *)&msgp->ms_mcp30), NULL ); #else flt1 = decode_prr_chan( getIntelword((Byte *)&msgp->ms_mcp10), &spec_cal.spc_cal[2][10] ); flt2 = decode_prr_chan( getIntelword((Byte *)&msgp->ms_mcp30), &spec_cal.spc_cal[2][11] ); #endif print_sensor( MCP_FILE, "%8.4f %8.2f %8.2f\n", day, flt1, flt2 ); } } /* printMisc() */ /************************************************************************/ /* Function : printMiscRev2 */ /* Purpose : Print Miscellaneous message buffer (Rev 1/2) */ /* Inputs : File day, Misc msg ptr */ /* Outputs : None */ /************************************************************************/ Void printMiscRev2( Flt64 day, MiscMsg *msgp ) { printMisc( day, msgp ); if ( reverseNO3 ) { printNO3( NO3_0_FILE, day, &msgp->ms_no3 ); printTemp( TEMP0_FILE, day, &msgp->ms_no3 ); } else { printNO3( NO3_20_FILE, day, &msgp->ms_no3 ); printTemp( TEMP20_FILE, day, &msgp->ms_no3 ); } } /* printMiscRev2() */ /************************************************************************/ /* Function : printMiscRev3 */ /* Purpose : Print Miscellaneous message buffer (Rev 3) */ /* Inputs : File day, Misc msg ptr */ /* Outputs : None */ /************************************************************************/ Void printMiscRev3( Flt64 day, Misc3Msg *msgp ) { Reg Nat32 i, ifluor; Reg Byte *fluorp; Flt64 fluor; printMisc( day, (MiscMsg *)msgp ); fluorp = msgp->ms_wetstar.fl_0m; for ( i = 0; i < CHEM_SAMPLES; i++ ) { ifluor = (Nat32)(fluorp[i]); fluor = (((analog[FLUOR_CHAN].a * (Flt64)(ifluor)) + analog[FLUOR_CHAN].b) * analog[FLUOR_CHAN].c) + analog[FLUOR_CHAN].d; print_sensor( WETSTAR_FILE, "%8.4f %5.2f\n", day + CHEM_TIME(i), fluor ); } } /* printMiscRev3() */ /************************************************************************/ /* Function : printMiscRev4 */ /* Purpose : Print Miscellaneous message buffer (Rev 4) */ /* Inputs : File day, Misc msg ptr */ /* Outputs : None */ /************************************************************************/ Void printMiscRev4( Flt64 day, Misc4Msg *msgp ) { Nat32 index, index20m; Nat32 val; Nat16 sval; Reg Byte *fluorp; Int16 co2; Flt64 flt1, flt2, flt3; sval = getIntelword( (Byte *)&msgp->ms_pco2 ); co2 = sval & 0xfff; if ( co2 & 0x800 ) co2 |= ~0xfff; /* Sign extend */ print_sensor( CO2_CAL_FILE, "%8.4f %3d %02d00\n", day, co2, 3 * ((sval >> 12) & 7) ); /* does unix need this?...Win32 wants val=msgp->ms_oasis */ /*val = getIntellong( (Byte *)&msgp->ms_oasis );*/ #ifdef WIN32 val=msgp->ms_oasis; #else val = getIntellong( (Byte *)(&msgp->ms_oasis) ); #endif flt1 = (((analog[TEMP_CHAN].a * (Flt32)(val & 0x3ff)) + analog[TEMP_CHAN].b) * analog[TEMP_CHAN].c) + analog[TEMP_CHAN].d; flt2 = ((analog[OBATT_CHAN].a * (Flt32)((val >> 10) & 0x3ff)) + analog[OBATT_CHAN].b) * analog[OBATT_CHAN].c; flt3 = ((analog[ABATT_CHAN].a * (Flt32)((val >> 20) & 0x3ff)) + analog[ABATT_CHAN].b) * analog[ABATT_CHAN].c; print_sensor( OASIS_FILE, "%8.4f %5.2f %5.2f %5.2f\n", day, flt1, flt2, flt3 ); fluorp= msgp->fl_0m; for ( index = index20m = 0; index < CHEM_SAMPLES; index++ ) { if ( index & 1 ) { val = (*fluorp++ & 0x0f) << 8; val |= *fluorp++; } else { val = *fluorp++ << 4; val |= ((*fluorp >> 4) & 0x0f); } flt1 = (((analog[FLUOR_CHAN].a * (Flt64)(val>>2)) + analog[FLUOR_CHAN].b) * analog[FLUOR_CHAN].c) + analog[FLUOR_CHAN].d; print_sensor( WETSTAR_FILE, "%8.4f %6.3f", day + CHEM_TIME(index), flt1 ); if ( (index != 1) && (index != 7) ) { val = getIntelword( (Byte *)&msgp->fl_20m[index20m] ); flt1 = decode_prr_chan((Int16)val, &spec_cal.spc_cal[2][11]); if ( flt1 < 20.0 ) print_sensor( WETSTAR_FILE, " %6.3f", flt1 ); index20m++; } print_sensor( WETSTAR_FILE, "\n" ); } } /* printMiscRev4() */ /************************************************************************/ /* Function : crcOneWord */ /* Purpose : Check CRC-12 on one 16 bit word */ /* Inputs : Initial CRC, word to check */ /* Outputs : Resulting CRC */ /************************************************************************/ Nat16 crcOneWord( Nat16 initCRC, Nat16 wordToCheck ) { Reg Nat32 bitCnt; Reg Nat16 crc; crc = initCRC; for ( bitCnt = 0; bitCnt < 16; bitCnt++ ) { crc <<= 1; if ( wordToCheck & (0x8000 >> bitCnt) ) crc |= 1; if ( crc & CRC_MSB ) crc ^= CRC12; } return( crc ); } /* crcOneWord() */ /************************************************************************/ /* Function : checkCRC */ /* Purpose : Check CRC-12 on incoming message */ /* Inputs : Word Message Pointer */ /* Outputs : TRUE if CRC is OK, else FALSE */ /* Comment : OASIS uses the standard CRC-12 polynomial 0x180f */ /* However, it puts the checksum and type information in */ /* the first word of the message, which it checks LAST */ /************************************************************************/ MBool checkCRC( WordMsg *msgp ) { Reg Nat32 cnt; Reg Nat16 crc; for ( cnt = 1, crc = 0; cnt < ARGOS_WORDS; cnt++ ) crc = crcOneWord( crc, getIntelword((Byte *)&msgp->wd_data[cnt]) ); return( crcOneWord(crc, getIntelword((Byte *)&msgp->wd_data[0])) == 0 ); } /* checkCRC() */ /************************************************************************/ /* Function : checkSum */ /* Purpose : Calculate Checksum on incoming message (Revision 1) */ /* Inputs : Byte Message Pointer */ /* Outputs : TRUE if checksum is OK, else FALSE */ /* Comment : Revision 1 of OASIS software used a simple checksum */ /************************************************************************/ MBool checkSum( ByteMsg *msgp ) { Reg Nat32 cnt; Byte cksum; for ( cnt = 2, cksum = 0; cnt < ARGOS_LEN; cnt++ ) cksum ^= msgp->by_data[cnt]; return( cksum == msgp->by_data[1] ); } /* checkSum() */ /************************************************************************/ /* Function : printOneMsgRev2 */ /* Purpose : Print one received ARGOS message in Rev 1/2 format */ /* Inputs : Message Pointer */ /* Outputs : None */ /************************************************************************/ Void printOneMsgRev2( ArgosInMsg *msgp ) { Nat32 msgType; Nat16 ifluor; Flt64 fdate, fluor; if ( revision == 1 ) { msgType = msgp->msg.rawb.by_data[0]; if ( (msgType & 0x0f) != ((msgType >> 4) & 0x0f) ) return; if ( !checkSum(&msgp->msg.rawb) ) return; msgType = msgTypesRev1[msgType & 0x0f]; } else { msgType = (msgp->msg.rawb.by_data[1] >> 4) & 0x0f; if ( !checkCRC(&msgp->msg.raww) ) return; } if ( !decode_all && !decode_msg[msgType] ) return; fdate = fileDate( msgp->first_msg ); switch( msgType ) { case CHEM: printChem( fdate, &msgp->msg.chem ); if ( reverseNO3 ) { printNO3( NO3_20_FILE, fdate, &msgp->msg.chem.ch_no3 ); printTemp( TEMP20_FILE, fdate, &msgp->msg.chem.ch_no3 ); } else { printNO3( NO3_0_FILE, fdate, &msgp->msg.chem.ch_no3 ); printTemp( TEMP0_FILE, fdate, &msgp->msg.chem.ch_no3 ); } break; case SPEC_0M_NOON: ifluor = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); fluor = (((analog[FLUOR_CHAN].a * (Flt64)(ifluor)) + analog[FLUOR_CHAN].b) * analog[FLUOR_CHAN].c) + analog[FLUOR_CHAN].d; printSpec( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_NOON_FILE, "%9.5f\n", fluor ); break; case SPEC_0M_AM: ifluor = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); fluor = (((analog[FLUOR_CHAN].a * (Flt64)(ifluor)) + analog[FLUOR_CHAN].b) * analog[FLUOR_CHAN].c) + analog[FLUOR_CHAN].d; printSpec( SPEC_1030_FILE, fdate, &msgp->msg.spec0m_1030, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_AM_LU_CHAN ); print_sensor( SPEC_1030_FILE, "%9.5f\n", fluor ); break; case SPEC_20M: ifluor = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); #if SPEC_VOLTS fluor = decode_prr_chan( ifluor, NULL ); #else fluor = decode_prr_chan( ifluor, &spec_cal.spc_cal[2][12] ); #endif printSpec( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20_FILE, "%9.5f\n", fluor ); break; case AC9_1: printAc9First( fdate, &msgp->msg.ac9 ); break; case AC9_2: printAc9Second( fdate, &msgp->msg.ac92 ); break; case MISC: printMiscRev2( fdate, &msgp->msg.misc ); break; default: print_error( "Bad Message Type %d\n", msgType ); } print_sensor( ARGOS_FILE, "%8.4f %2d %3d\n", fdate, msgType, msgp->msg_cnt ); } /* printOneMsgRev2() */ /************************************************************************/ /* Function : printOneMsgRev3_4 */ /* Purpose : Print one received ARGOS message in Rev 3 or 4 format */ /* Inputs : Message Pointer */ /* Outputs : None */ /************************************************************************/ Void printOneMsgRev3_4( ArgosInMsg *msgp, Int32 rev ) { Nat32 msgType; Nat16 misc, val; Reg Nat32 i; Flt64 fdate, lu; if ( (rev != 3) && (rev != 4) ) { print_error("Internal error - wrong message revision\n"); return; } msgType = (msgp->msg.rawb.by_data[1] >> 4) & 0x0f; if ( !checkCRC(&msgp->msg.raww) ) return; if ( !decode_all && !decode_msg[msgType] ) return; fdate = fileDate( msgp->first_msg ); switch( msgType ) { case CHEM: if ( rev == 3 ) { printChem( fdate, &msgp->msg.chem ); printNO3( NO3_0_FILE, fdate, &msgp->msg.chem.ch_no3 ); printTemp( TEMP0_FILE, fdate, &msgp->msg.chem.ch_no3 ); } else printChem4( fdate, &msgp->msg.chem4 ); break; case SPEC_0M_NOON: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpec( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_NOON_FILE, "%u\n", misc ); break; case SPEC_0M_1230: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpec( SPEC_0M_1230_FILE, fdate, &msgp->msg.spec0m_1230, SPEC_0M_ED, SPEC_0M_LU, 0, ((rev == 3) ? SPEC_1230_LU_CHAN : SPEC_1230_LU_CHAN_REV4) ); print_sensor( SPEC_0M_1230_FILE, "%u\n", misc ); break; case SPEC_20M: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpec( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); if ( rev == 3 ) print_sensor( SPEC_20_FILE, "%u\n", misc ); else { print_sensor( SPEC_20_FILE, "\n" ); #if SPEC_VOLTS print_sensor( MCP_FILE, "%8.4f 10 %9.5f\n", fdate, decode_prr_chan(misc, NULL)); #else print_sensor( MCP_FILE, "%8.4f 10 %9.5f\n", fdate, decode_prr_chan(misc, &spec_cal.spc_cal[2][10])); #endif } break; case SPEC_20M_1230: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpec( SPEC_20M_1230_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); if ( rev == 3 ) print_sensor( SPEC_20M_1230_FILE, "%u\n", misc ); else { print_sensor( SPEC_20M_1230_FILE, "\n" ); #if SPEC_VOLTS print_sensor( MCP_FILE, "%8.4f 30 %9.5f\n", fdate, decode_prr_chan(misc, NULL)); #else print_sensor( MCP_FILE, "%8.4f 30 %9.5f\n", fdate, decode_prr_chan(misc, &spec_cal.spc_cal[2][14])); #endif } break; case SPEC_0M_DARK: printSpec( SPEC_0M_DARK_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_0M_DARK_FILE, "\n" ); break; case SPEC_20M_DARK: printSpec( SPEC_20M_DARK_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20M_DARK_FILE, "\n" ); break; case SAT1: printSpec( SAT1_FILE, fdate, &msgp->msg.sat1, SAT1_ED, SAT1_LU, SAT1_ED_CHAN, SAT1_LU_CHAN ); print_sensor( SAT1_FILE, "\n" ); break; case SHUTTR: print_sensor(SHUTTER_FILE, "%8.4f %3d %3d %3d %2d %2d %2d %2d %04x\n", fdate, getIntelword((Byte *)&msgp->msg.shutter.sh_attempts), msgp->msg.shutter.sh_opens, msgp->msg.shutter.sh_closes, msgp->msg.shutter.sh_toterrs, msgp->msg.shutter.sh_errs[0], msgp->msg.shutter.sh_errs[1], msgp->msg.shutter.sh_errs[2], getIntelword((Byte *)&msgp->msg.shutter.sh_oasisErrs)); print_sensor( SAT1_DARK_FILE, "%8.4f ", fdate ); for ( i = 0; i < ASPEC_CHANS; i++ ) { val = getIntelword( (Byte *)&msgp->msg.shutter.sh_satDark[i] ); #if SPEC_VOLTS lu = decode_prr_chan( val, NULL ); #else lu = decode_prr_chan( val, &spec_cal.spc_cal[SPEC_0M_LU][SPEC_1230_LU_CHAN+i] ); #endif print_sensor( SAT1_DARK_FILE, "%9.5f ", lu ); } print_sensor( SAT1_DARK_FILE, "\n" ); if ( rev == 4 ) { val = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_temp ); misc = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_cond ); print_sensor( TEMP0_FILE, "%8.4f %7.3f %8.4f\n", fdate, ((double)val) / 1000., ((double)misc) / 10000.); } break; case MISC: if ( rev == 3 ) printMiscRev3( fdate, &msgp->msg.misc3 ); else printMiscRev4( fdate, &msgp->msg.misc4 ); break; default: print_error( "Bad Message Type %d\n", msgType ); } print_sensor( ARGOS_FILE, "%8.4f %2d %3d\n", fdate, msgType, msgp->msg_cnt ); } /* printOneMsgRev3_4() */ /************************************************************************/ /* Function : printOneMsgR5 */ /* Purpose : Print one received ARGOS message in Rev 5 format */ /* Inputs : Message Pointer */ /* Outputs : None */ /************************************************************************/ Void printOneMsgR5( ArgosInMsg *msgp, Int32 rev ) { Nat32 msgType; Nat16 misc, val; Reg Nat32 i; Flt64 fdate, lu; if ( (rev != 5) ) { print_error("Internal error - wrong message revision\n"); return; } msgType = (msgp->msg.rawb.by_data[1] >> 4) & 0x0f; if ( !checkCRC(&msgp->msg.raww) ) return; if ( !decode_all && !decode_msg[msgType] ) return; fdate = fileDate( msgp->first_msg ); mType=msgType; switch( msgType ) { case CHEM: printChemR5( fdate, &msgp->msg.chem5 ); break; case SPEC_0M_NOON: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecR5( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_NOON_FILE, "%u\n", misc ); break; case SPEC_0M_1000: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecR5( SPEC_0M_1000_FILE, fdate, &msgp->msg.spec0m_1000, SPEC_0M_ED, SPEC_0M_LU, 0, (SPEC_1000_LU_CHAN_REV5) ); print_sensor( SPEC_0M_1000_FILE, "%u\n", misc ); break; case SPEC_20M: printSpecR5( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20_FILE, "\n" ); break; case SPEC_20M_1000: printSpecR5( SPEC_20M_1000_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20M_1000_FILE, "\n" ); break; case SPEC_0M_DARK: printSpecR5( SPEC_0M_DARK_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_0M_DARK_FILE, "\n" ); break; case SPEC_20M_DARK: printSpecR5( SPEC_20M_DARK_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20M_DARK_FILE, "\n" ); break; case SAT1: printSpecR5( SAT1_FILE, fdate, &msgp->msg.sat1, SAT1_ED, SAT1_LU, SAT1_ED_CHAN, SAT1_LU_CHAN ); print_sensor( SAT1_FILE, "\n" ); break; case SHUTTR: print_sensor(SHUTTER_FILE, "%8.4f %3d %3d %3d %2d %2d %2d %2d %04x\n", fdate, getIntelword((Byte *)&msgp->msg.shutter.sh_attempts), msgp->msg.shutter.sh_opens, msgp->msg.shutter.sh_closes, msgp->msg.shutter.sh_toterrs, msgp->msg.shutter.sh_errs[0], msgp->msg.shutter.sh_errs[1], msgp->msg.shutter.sh_errs[2], getIntelword((Byte *)&msgp->msg.shutter.sh_oasisErrs)); print_sensor( SAT1_DARK_FILE, "%8.4f ", fdate ); for ( i = 0; i < ASPEC_CHANS; i++ ) { val = getIntelword( (Byte *)&msgp->msg.shutter.sh_satDark[i] ); #if SPEC_VOLTS lu = decode_prr_chan( val, NULL ); #else lu = decode_prr_chan( val, &spec_cal.spc_cal[SPEC_0M_LU][SPEC_1000_LU_CHAN+i] ); #endif print_sensor( SAT1_DARK_FILE, "%9.5f ", lu ); } print_sensor( SAT1_DARK_FILE, "\n" ); if ( rev == 5 ) { val = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_temp ); misc = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_cond ); print_sensor( TEMP0_FILE, "%8.4f %7.3f %8.4f\n", fdate, ((double)val) / 1000., ((double)misc) / 10000.); } break; case MISC: printMiscRev4( fdate, &msgp->msg.misc4 ); break; default: print_error( "Bad Message Type %d\n", msgType ); } print_sensor( ARGOS_FILE, "%8.4f %2d %3d\n", fdate, msgType, msgp->msg_cnt ); } /* printOneMsgR5() */ /************************************************************************/ /* Function : printOneMsgR6 */ /* Purpose : Print one received ARGOS message in Rev 6 format */ /* Inputs : Message Pointer */ /* Outputs : None */ /************************************************************************/ Void printOneMsgR6( ArgosInMsg *msgp, Int32 rev ) { Nat32 msgType; Nat16 misc, val; Reg Nat32 i; Flt64 fdate;/*, lu;*/ Nat32 j,k,*pNat32,pixels[3]; Byte *pIn,*pOut; Flt32 *pFloat; if ( (rev != 6) ) { print_error("Internal error - wrong message revision\n"); return; } msgType = (msgp->msg.rawb.by_data[1] >> 4) & 0x0f; if ( !checkCRC(&msgp->msg.raww) ) return; if ( !decode_all && !decode_msg[msgType] ) return; fdate = fileDate( msgp->first_msg ); mType=msgType; switch( msgType ) { case CHEM: printChemR5( fdate, &msgp->msg.chem5 ); break; case SPEC_0M_NOON: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecR5( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_NOON_FILE, "%u\n", misc ); break; case SPEC_0M_1000: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecR5( SPEC_0M_1000_FILE, fdate, &msgp->msg.spec0m_1000, SPEC_0M_ED, SPEC_0M_LU, 0, (SPEC_1000_LU_CHAN_REV5) ); print_sensor( SPEC_0M_1000_FILE, "%u\n", misc ); break; case SPEC_20M: printSpecR5( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20_FILE, "\n" ); break; case SPEC_20M_1000: printSpecR5( SPEC_20M_1000_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20M_1000_FILE, "\n" ); break; case SPEC_0M_DARK: printSpecR6( fdate, &msgp->msg.spec0m); break; case SPEC_20M_DARK: printSpecR6( fdate, &msgp->msg.spec20m); break; case SAT1: printSpecR5( SAT1_FILE, fdate, &msgp->msg.sat1, SAT1_ED, SAT1_LU, SAT1_ED_CHAN, SAT1_LU_CHAN ); print_sensor( SAT1_FILE, "\n" ); break; case SHUTTR: print_sensor(SHUTTER_FILE, "%8.4f %3d %3d %3d %2d %2d %2d %2d %04x\n", fdate, getIntelword((Byte *)&msgp->msg.shutter.sh_attempts), msgp->msg.shutter.sh_opens, msgp->msg.shutter.sh_closes, msgp->msg.shutter.sh_toterrs, msgp->msg.shutter.sh_errs[0], msgp->msg.shutter.sh_errs[1], msgp->msg.shutter.sh_errs[2], getIntelword((Byte *)&msgp->msg.shutter.sh_oasisErrs)); /* In Rev6, there are 3 4-Byte floats for HR3 412 nm data */ /* pFloat = (Flt32 *) &msgp->msg.shutter.sh_satDark[0]; for ( i = 0; i < 3; i++ ) { print_sensor( HR3_FILE, "%8.4f %d 412 %9.4f\n", fdate, i, *(pFloat+i) ); } */ pNat32 = (Nat32 *) &(msgp->msg.shutter.sh_satDark[0]); for(i=0;i<3;i++){ pixels[i]=0; pIn = (Byte *)&pNat32[i]; pOut = (Byte *)&pixels[i]; #ifdef WIN32 /* swap byte order for WIN32 */ for(j=0,k=3;j<4;j++,k--) *(pOut+j) = *(pIn+k); #else for(j=0,k=0;j<4;j++,k++) *(pOut+j) = *(pIn+k); #endif pFloat = (Flt32 *)&pixels[i]; print_sensor( HR3_FILE, "%8.4f %d 412 %9.4f\n", fdate, i, *pFloat ); /*printf( "\t%d 412 %f\n",i,*pFloat);*/ } if ( rev == 5 || rev ==6) { val = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_temp ); misc = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_cond ); print_sensor( TEMP0_FILE, "%8.4f %7.3f %8.4f\n", fdate, ((double)val) / 1000., ((double)misc) / 10000.); } break; case MISC: printMiscRev4( fdate, &(msgp->msg.misc4) ); break; default: print_error( "Bad Message Type %d\n", msgType ); break; } print_sensor( ARGOS_FILE, "%8.4f %2d %3d\n", fdate, msgType, msgp->msg_cnt ); } /* printOneMsgR6() */ /************************************************************************/ /* Function : printOneMsg */ /* Purpose : Print one received ARGOS message */ /* Inputs : Message Pointer */ /* Outputs : None */ /************************************************************************/ Void printOneMsg( ArgosInMsg *msgp ) { switch( revision ) { case 1: case 2: printOneMsgRev2( msgp ); break; case 3: printOneMsgRev3_4( msgp, 3 ); break; case 4: printOneMsgRev3_4( msgp, 4 ); break; case 5: printOneMsgR5( msgp, 5 ); break; case 6: printOneMsgR6( msgp, 6 ); break; default: printf( "Bad software revision number %d\n", revision ); break; } } /* printOneMsg() */ /************************************************************************/ /* Function : decodeFile */ /* Purpose : Decode one ARGOS message file */ /* Inputs : File name */ /* Outputs : None */ /************************************************************************/ Void decodeFile( char *filename ) { Reg Nat32 i; Reg FILE *fp; if ( (fp = fopen(filename, "rb")) == (FILE *)NULL ) fprintf(stderr, "Cannot open %s\n", filename); else { getMessages( fp, buffer ); for ( i = 0; i < msgCnt; i++ ){ printOneMsg( &msgs[i] ); } } close_sensor_files(); } /* printMessages() */ @ 3.10 log @fixed bug in battery decoding (getIntellong() declared to return Nat16 instead of Nat32) @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.9 2002/06/10 14:40:44 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.9 $ */ d23 4 d1355 1 d1360 2 a1361 2 val = getIntelword( (Byte *)&msgp->ms_pco2 ); co2 = val & 0xfff; d1366 1 a1366 1 day, co2, 3 * ((val >> 12) & 7) ); @ 3.9 log @fix argos mail input for win32 fix hr3 byte order for unix @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.8 2002/04/23 12:02:02 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.8 $ */ d23 4 d77 2 a78 2 #define YEAR0 70 #define MAX_PTTS 8 a87 8 typedef enum /********************************/ { /* Type of input */ SVC_ARGOS=0, /* From Serivce Argos */ RCVR_NORM, /* From local receiver, normal mode*/ RCVR_DIAG, /* Local receiver, diagnostic mode*/ ALPHA_OMEGA /* Alpha-Omega receiver */ } InputMode; /********************************/ d89 7 d97 1 d109 5 a113 5 #ifdef WIN32 Extern Int getopt( Int argc, char **argv, char *fmt ); #endif Extern Nat16 getIntelword( Byte *p ); Extern Nat16 getIntellong( Byte *p ); a128 1 d130 1 d135 6 a140 6 #ifdef WIN32 MLocal InputMode inputMode = RCVR_DIAG; #else MLocal InputMode inputMode = SVC_ARGOS; #endif d144 3 a146 3 MLocal MBool decode_all_ptt=TRUE; MLocal Nat32 ptt_count=0; MLocal Nat32 decode_ptt[MAX_PTTS]; d182 1 a182 1 d209 1 a209 1 fprintf( stderr, "-a is for an Alpha-Omega receiver\n" ); d211 2 a212 2 fprintf( stderr, "-d is for a Telonics receiver in diagnostic mode\n" ); fprintf( stderr, "-e is for a email received from Service Argos\n" ); d215 2 a216 2 fprintf( stderr, "-n is for a Telonics receiver in normal mode\n" ); fprintf( stderr, "-p decodes a specified PTT number\n"); d1349 2 a1350 1 Nat32 val, index, index20m; d1352 1 a1352 1 Int32 co2; d1362 10 a1371 2 val = getIntellong( (Byte *)&msgp->ms_oasis ); d1373 6 a1378 5 analog[TEMP_CHAN].b) * analog[TEMP_CHAN].c) + analog[TEMP_CHAN].d; flt2 = ((analog[OBATT_CHAN].a * (Flt32)((val >> 10) & 0x3ff)) + analog[OBATT_CHAN].b) * analog[OBATT_CHAN].c; flt3 = ((analog[ABATT_CHAN].a * (Flt32)((val >> 20) & 0x3ff)) + analog[ABATT_CHAN].b) * analog[ABATT_CHAN].c; d1380 2 a1381 1 print_sensor( OASIS_FILE, "%8.4f %5.2f %8.2f %8.2f\n", d2016 1 a2016 1 printMiscRev4( fdate, &msgp->msg.misc4 ); @ 3.8 log @Support for HS2, HR3 @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.6 2002/03/01 15:37:52 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.6 $ */ d23 3 d237 4 a240 4 case 'a': inputMode = ALPHA_OMEGA; break; d245 4 a248 4 case 'd': inputMode = RCVR_DIAG; break; d257 4 a260 4 case 'e': inputMode = SVC_ARGOS; break; a264 10 case 'n': inputMode = RCVR_NORM; break; case 'p': decode_all_ptt=FALSE; if(ptt_count<=MAX_PTTS) decode_ptt[ptt_count++] = atoi(optarg); break; d266 10 d279 1 a279 1 }/* end switch*/ d301 1 a301 1 { d303 1 a303 1 if ( (cp=fgets(buffer, BUFSIZE, fp)) == NULL ){ d309 1 a309 1 buffer[len] = '\0'; d311 3 a313 3 }else{ return(END_OF_FILE); } d363 12 a374 177 /************************************************************************/ /* Function : getNormalMsg */ /* Purpose : Get an ARGOS message in normal format for local rcvr */ /* Inputs : FILE ptr, Buffer ptr, message ptr for return message */ /* Outputs : Message return code */ /************************************************************************/ MsgRtn getNormalMsg( FILE *fp, char *buffer, ByteMsg *msgp, struct tm *tmPtr ) { Nat32 i, j, dat[8]; Nat32 ptt; MBool isValidPTT=FALSE; if ( getLine(fp, buffer) == END_OF_FILE ){ return( END_OF_FILE ); } if ( sscanf(buffer, " %d-%d-%d %d:%d:%d ID %d", &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_year, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec,&ptt) < 7 ){ return( BAD_MSG ); } if(!decode_all_ptt){ for(i=0;itm_mon -= 1; if ( tmPtr->tm_year < YEAR0 ) tmPtr->tm_year += 100; /* Y2k fix 4/16/2001 klh*/ for ( i = 0; i < ARGOS_LEN; i += 8 ) { if ( getLine(fp, buffer) == END_OF_FILE ){ return( END_OF_FILE ); } if ( sscanf(buffer, " %d %d %d %d %d %d %d %d", &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5], &dat[6], &dat[7]) < 8 ){ return( BAD_MSG ); } for ( j = 0; j < 8; j++ ) msgp->by_data[i + j] = (Byte)dat[j]; } return( MSG_OK ); } /* getNormalMsg() */ /************************************************************************/ /* Function : getDiagnosticMsg */ /* Purpose : Get an ARGOS message in diagnostic format for local rcvr*/ /* Inputs : FILE ptr, Buffer ptr, message ptr for return message */ /* Outputs : Message return code */ /************************************************************************/ MsgRtn getDiagnosticMsg( FILE *fp, char *buffer, ByteMsg *msgp, struct tm *tmPtr ) { Nat32 i, j, dat[8]; Nat32 ptt; MBool isValidPTT=FALSE; if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %d-%d-%d %d:%d:%d ID %d", &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_year, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec, &ptt) < 7 ) return( BAD_MSG ); if(!decode_all_ptt){ for(i=0;itm_mon -= 1; if ( tmPtr->tm_year < YEAR0 ) tmPtr->tm_year += 100; /* Y2k fix 5/22/2000 rah*/ if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %*x %*x %*x %*x %*x %*x %x %x", &dat[0], &dat[1]) < 2) return( BAD_MSG ); msgp->by_data[0] = (Byte)dat[0]; msgp->by_data[1] = (Byte)dat[1]; for ( i = 2; i < ARGOS_LEN - 6; i += 8 ) { if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %x %x %x %x %x %x %x %x", &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5], &dat[6], &dat[7]) < 8 ) return( BAD_MSG ); for ( j = 0; j < 8; j++ ) msgp->by_data[i + j] = (Byte)dat[j]; } if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %x %x %x %x %x %x", &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5]) < 6 ) return( BAD_MSG ); for ( j = 0; j < 6; j++ ) msgp->by_data[i + j] = (Byte)dat[j]; /*getLine( fp, buffer );*/ return( MSG_OK ); } /* getDiagnosticMsg() */ /************************************************************************/ /* Function : getAlphaOmegaMsg */ /* Purpose : Get an ARGOS message in Alpha-Omega Receiver format */ /* Inputs : FILE ptr, Buffer ptr, message ptr for return message */ /* Outputs : Message return code */ /* Comment : Assumes A-O rcvr in byte format, which is not default */ /************************************************************************/ MsgRtn getAlphaOmegaMsg( FILE *fp, char *buffer, ByteMsg *msgp, struct tm *tmPtr ) { Nat32 pttNum, i, dat[32]; MBool isValidPTT=FALSE; if ( getLine(fp, buffer) == END_OF_FILE ) return( END_OF_FILE ); if ( sscanf(buffer, " %d/%d/%d %d:%d:%d %d %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", &tmPtr->tm_mon, &tmPtr->tm_mday, &tmPtr->tm_year, &tmPtr->tm_hour, &tmPtr->tm_min, &tmPtr->tm_sec, &pttNum, &dat[0], &dat[1], &dat[2], &dat[3], &dat[4], &dat[5], &dat[6], &dat[7], &dat[8], &dat[9], &dat[10], &dat[11], &dat[12], &dat[13], &dat[14], &dat[15], &dat[16], &dat[17], &dat[18], &dat[19], &dat[20], &dat[21], &dat[22], &dat[23], &dat[24], &dat[25], &dat[26], &dat[27], &dat[28], &dat[29], &dat[30], &dat[31]) < 39 ) return( BAD_MSG ); if(!decode_all_ptt){ for(i=0;itm_year -= 1900; tmPtr->tm_mon -= 1; for ( i = 0; i < 32; i++ ) msgp->by_data[i] = (Byte)dat[i]; return( MSG_OK ); } /* getAlhpaOmegaMsg() */ d376 46 d423 119 a606 22 switch( inputMode ) { case SVC_ARGOS: state = getSvcArgosMsg( fp, buffer, &msg.raww, &msgTime, &nmsgs ); break; case RCVR_NORM: state = getNormalMsg( fp, buffer, &msg.rawb, &msgTime ); break; case RCVR_DIAG: state = getDiagnosticMsg( fp, buffer, &msg.rawb, &msgTime ); break; case ALPHA_OMEGA: state = getAlphaOmegaMsg( fp, buffer, &msg.rawb, &msgTime ); break; default: return; } d608 22 d632 1 a632 1 { d660 2 a661 2 }/* end if MSG_OK */ }/* end while */ d793 2 a794 2 co2 |= 0xfffff000; /* Sign extend */ a795 1 d797 1 d872 1 a872 1 unsigned char w[2]; d874 1 a874 1 d876 1 a876 1 a946 33 /************************************************************************/ /* Function : printHR3 */ /* Purpose : Print Hobi HR3 data (stored in sp_lu[] of SAT1Msg) */ /* Inputs : ? */ /* Outputs : None */ /************************************************************************/ Void printHR3(Nat32 filenum, Flt64 day, void *msgp) { char w[2]; print_sensor(filenum,"%8.4f",day); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[0],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[1],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[2],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[3],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[4],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[5],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); memmove((Byte *)&w[0],(Byte *)&((SpecMsg *)msgp)->sp_lu[6],2); print_sensor(filenum," %02X %02X",w[0]&0xFF,w[1]&0xFF); print_sensor(filenum,"\n"); return; }/*printHR3()*/ d949 33 d1048 1 a1048 1 } d1073 68 a1140 62 /************************************************************************/ /* Function : printSpecR6 */ /* Purpose : Print a PRR Spectro message rev 6 format */ /* NOTE: Only for extracting HR data from selected messages */ /* Inputs : File day, Spectro message ptr */ /* Outputs : None */ /************************************************************************/ Void printSpecR6( Flt64 day, SpecMsg *msgp ) { /* Reg Int32 i; Reg Flt32 *pEd,*pLu; if(mType == SPEC_0M_DARK){ pEd = (Flt32 *) &msgp->sp_ed[0]; pLu = (Flt32 *) &msgp->sp_lu[0]; for ( i = 0; i < 3; i++ ) { print_sensor( HR3_FILE, "%8.4f %d 443 %9.4f\n", day, i, *(pEd+i) ); print_sensor( HR3_FILE, "%8.4f %d 490 %9.4f\n", day, i, *(pLu+i) ); } }else if(mType == SPEC_20M_DARK){ pEd = (Flt32 *) &msgp->sp_ed[0]; pLu = (Flt32 *) &msgp->sp_lu[0]; for ( i = 0; i < 3; i++ ) { print_sensor( HR3_FILE, "%8.4f %d 510 %9.4f\n", day, i, *(pEd+i) ); print_sensor( HR3_FILE, "%8.4f %d 555 %9.4f\n", day, i, *(pLu+i) ); } } */ Reg Int32 i; Nat32 *pNEd,*pNLu; Nat32 j,k,pixels[2][3]; Byte *pIn[2], *pOut[2]; Flt32 *pFloat[2]; pNEd = (Nat32 *) &msgp->sp_ed[0]; pNLu = (Nat32 *) &msgp->sp_lu[0]; for ( i = 0; i < 3; i++ ) { pixels[0][i]=0; pixels[1][i]=0; pIn[0] = (Byte *)&pNEd[i]; pOut[0] = (Byte *)&pixels[0][i]; pIn[1] = (Byte *)&pNLu[i]; pOut[1] = (Byte *)&pixels[1][i]; for(j=0,k=3;j<4;j++,k--){ *(pOut[0]+j) = *(pIn[0]+k); *(pOut[1]+j) = *(pIn[1]+k); } pFloat[0] = (Flt32 *)&pixels[0][i]; pFloat[1] = (Flt32 *)&pixels[1][i]; switch(mType){ case SPEC_0M_DARK: d1142 2 a1143 2 //printf( "\t%d 443 %f\n", i , *pFloat[0] ); //printf( "\t%d 490 %f\n", i , *pFloat[1] ); d1145 4 a1148 4 print_sensor( HR3_FILE, "%8.4f %d 443 %9.4f\n", day, i, *pFloat[0] ); print_sensor( HR3_FILE, "%8.4f %d 490 %9.4f\n", day, i, *pFloat[1] ); break; case SPEC_20M_DARK: d1150 2 a1151 2 //printf( "\t%d 510 %f\n", i , *pFloat[0] ); //printf( "\t%d 555 %f\n", i , *pFloat[1] ); d1153 5 a1157 12 print_sensor( HR3_FILE, "%8.4f %d 510 %9.4f\n", day, i, *pFloat[0] ); print_sensor( HR3_FILE, "%8.4f %d 555 %9.4f\n", day, i, *pFloat[1] ); break; default: break; }/*end switch*/ }/* end for i*/ return; } /* printSpecR6() */ d1159 7 d1763 1 a1763 1 return; a1769 1 d1771 3 a1773 2 mType=msgType; d1776 1 a1776 1 case CHEM: d1866 1 a1866 1 d1871 117 a1987 113 /************************************************************************/ /* Function : printOneMsgR6 */ /* Purpose : Print one received ARGOS message in Rev 6 format */ /* Inputs : Message Pointer */ /* Outputs : None */ /************************************************************************/ Void printOneMsgR6( ArgosInMsg *msgp, Int32 rev ) { Nat32 msgType; Nat16 misc, val; Reg Nat32 i; Flt64 fdate;/*, lu;*/ Nat32 j,k,*pNat32,pixels[3]; Byte *pIn,*pOut; Flt32 *pFloat; if ( (rev != 6) ) { print_error("Internal error - wrong message revision\n"); return; } msgType = (msgp->msg.rawb.by_data[1] >> 4) & 0x0f; if ( !checkCRC(&msgp->msg.raww) ) return; if ( !decode_all && !decode_msg[msgType] ) return; fdate = fileDate( msgp->first_msg ); mType=msgType; switch( msgType ) { case CHEM: printChemR5( fdate, &msgp->msg.chem5 ); break; case SPEC_0M_NOON: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecR5( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, 0, SPEC_NOON_LU_CHAN ); print_sensor( SPEC_NOON_FILE, "%u\n", misc ); break; case SPEC_0M_1000: misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecR5( SPEC_0M_1000_FILE, fdate, &msgp->msg.spec0m_1000, SPEC_0M_ED, SPEC_0M_LU, 0, (SPEC_1000_LU_CHAN_REV5) ); print_sensor( SPEC_0M_1000_FILE, "%u\n", misc ); break; case SPEC_20M: printSpecR5( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20_FILE, "\n" ); break; case SPEC_20M_1000: printSpecR5( SPEC_20M_1000_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, 0 ); print_sensor( SPEC_20M_1000_FILE, "\n" ); break; case SPEC_0M_DARK: printSpecR6( fdate, &msgp->msg.spec0m); break; case SPEC_20M_DARK: printSpecR6( fdate, &msgp->msg.spec20m); break; case SAT1: printSpecR5( SAT1_FILE, fdate, &msgp->msg.sat1, SAT1_ED, SAT1_LU, SAT1_ED_CHAN, SAT1_LU_CHAN ); print_sensor( SAT1_FILE, "\n" ); break; case SHUTTR: print_sensor(SHUTTER_FILE, "%8.4f %3d %3d %3d %2d %2d %2d %2d %04x\n", fdate, getIntelword((Byte *)&msgp->msg.shutter.sh_attempts), msgp->msg.shutter.sh_opens, msgp->msg.shutter.sh_closes, msgp->msg.shutter.sh_toterrs, msgp->msg.shutter.sh_errs[0], msgp->msg.shutter.sh_errs[1], msgp->msg.shutter.sh_errs[2], getIntelword((Byte *)&msgp->msg.shutter.sh_oasisErrs)); /* In Rev6, there are 3 4-Byte floats for HR3 412 nm data */ /* pFloat = (Flt32 *) &msgp->msg.shutter.sh_satDark[0]; for ( i = 0; i < 3; i++ ) { print_sensor( HR3_FILE, "%8.4f %d 412 %9.4f\n", fdate, i, *(pFloat+i) ); } */ pNat32 = (Nat32 *) &(msgp->msg.shutter.sh_satDark[0]); for(i=0;i<3;i++){ pixels[i]=0; pIn = (Byte *)&pNat32[i]; pOut = (Byte *)&pixels[i]; for(j=0,k=3;j<4;j++,k--) *(pOut+j) = *(pIn+k); pFloat = (Flt32 *)&pixels[i]; print_sensor( HR3_FILE, "%8.4f %d 412 %9.4f\n", fdate, i, *pFloat ); d1989 8 a1996 24 } if ( rev == 5 || rev ==6) { val = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_temp ); misc = getIntelword( (Byte *)&msgp->msg.shutter.sh_ctd_cond ); print_sensor( TEMP0_FILE, "%8.4f %7.3f %8.4f\n", fdate, ((double)val) / 1000., ((double)misc) / 10000.); } break; case MISC: printMiscRev4( fdate, &msgp->msg.misc4 ); break; default: print_error( "Bad Message Type %d\n", msgType ); break; } print_sensor( ARGOS_FILE, "%8.4f %2d %3d\n", fdate, msgType, msgp->msg_cnt ); } /* printOneMsgR6() */ d1998 16 d2022 1 a2022 1 { d2039 1 a2039 1 case 5: d2042 4 a2045 4 case 6: printOneMsgR6( msgp, 6 ); break; d2048 1 a2048 1 printf( "Bad software revision number %d\n", revision ); d2070 1 a2070 1 { d2072 2 a2073 2 for ( i = 0; i < msgCnt; i++ ){ printOneMsg( &msgs[i] ); @ 3.7 log @Bug fix in argextract, partial support for HR3 @ text @d486 1 a486 1 //getLine( fp, buffer ); d944 33 d1035 1 a1035 1 d1045 1 a1045 1 } d1047 1 d1050 1 a1050 1 printIsus( ISUS_FILE, day, (void *)msgp ); d1056 1 a1056 2 }else { d1070 86 d1862 138 d2029 4 @ 3.6 log @Support for Local receiver input, WIN32 @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.5 2001/06/19 12:59:40 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.5 $ */ d23 3 d84 1 a84 1 SVC_ARGOS, /* From Serivce Argos */ d175 1 a175 1 d231 1 a231 1 while ( (c = getopt(argc, argv, "ac:dD:ei:np:")) != EOF ) d276 2 a277 1 } d298 2 a299 1 { d306 1 a306 1 buffer[len] = '\0'; d308 1 a308 1 }else{ d383 1 a383 1 if(!decode_all_ptt){ d393 1 d486 1 a486 1 getLine( fp, buffer ); a657 1 a658 1 d1644 2 a1645 1 mType=msgType; d1660 1 a1660 1 misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); d1798 1 a1798 1 for ( i = 0; i < msgCnt; i++ ){ @ 3.5 log @Periodic Update w/ changes to utils plus new utils 6/19/2001 (klh) @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.4 2001/05/04 12:58:20 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.4 $ */ d23 4 d67 2 d78 8 d99 5 a104 1 d118 2 a120 1 d125 6 d134 3 d185 1 a185 1 d198 2 a199 1 fprintf( stderr, "Usage: %s [-c cfg_file] [-i msg_number]\n" ); d201 3 d205 2 d223 2 d228 1 a228 1 while ( (c = getopt(argc, argv, "c:i:")) != EOF ) d231 4 d239 16 d259 10 d290 1 a290 1 d293 1 a293 1 while( TRUE ) d295 12 a306 2 if ( fgets(buffer, BUFSIZE, fp) == NULL ) return( END_OF_FILE ); a307 8 if ( (len = strlen(buffer)) > 0 ) { if ( buffer[len] == '\n' ) buffer[len] = '\0'; return( MSG_OK ); } } d355 176 d598 22 d621 1 a621 2 state = getSvcArgosMsg( fp, buffer, &msg.raww, &msgTime, &nmsgs ); d623 1 a623 1 { d651 1 a651 2 } } d653 2 d776 1 a776 1 Nat16 ipitch, iroll, itemp, idepth; d786 2 a787 1 co2 |= 0xfffff000; /* Sign extend */ d789 1 d806 1 a806 1 d865 1 a865 2 unsigned char w[2]; Nat16 ival; d867 4 a870 3 print_sensor(filenum,"%8.4f ",day); if (mType == SPEC_0M_1000){ d921 1 a921 1 Nat16 i; d1015 1 a1015 1 if ( msgp->sp_type == SAT1 ) d1107 1 a1107 1 Nat32 i, val; d1259 1 a1259 1 flt1 = decode_prr_chan(val, &spec_cal.spc_cal[2][11]); d1622 1 a1622 1 d1631 1 a1631 1 return; d1633 1 d1638 1 d1643 1 a1643 1 case CHEM: d1655 1 a1655 1 misc = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); d1669 1 a1669 1 printSpecR5( SPEC_20M_1000_FILE, fdate, &msgp->msg.spec20m, d1675 1 a1675 1 printSpecR5( SPEC_0M_DARK_FILE, fdate, &msgp->msg.spec0m, d1681 1 a1681 1 printSpecR5( SPEC_20M_DARK_FILE, fdate, &msgp->msg.spec20m, d1687 1 a1687 1 printSpecR5( SAT1_FILE, fdate, &msgp->msg.sat1, d1733 1 a1733 1 d1747 2 a1748 1 { d1753 2 a1754 2 printOneMsgRev2( msgp ); break; d1757 2 a1758 2 printOneMsgRev3_4( msgp, 3 ); break; d1761 2 a1762 2 printOneMsgRev3_4( msgp, 4 ); break; d1764 3 a1766 3 case 5: printOneMsgR5( msgp, 5 ); break; d1769 2 a1770 1 printf( "Bad software revision number %d\n", revision ); d1791 5 a1795 5 { getMessages( fp, buffer ); for ( i = 0; i < msgCnt; i++ ) printOneMsg( &msgs[i] ); @ 3.4 log @change bcopy() to memmove() for WIN32 compatibility @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.3 2001/05/02 10:52:47 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.3 $ */ d11 8 d23 3 @ 3.3 log @new ISUS format @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.2 2001/04/25 09:28:37 oasisa Exp $ */ d9 1 a9 1 /* $Revision: 3.2 $ */ d15 3 d594 1 a594 1 bcopy((Byte *)&((SpecMsg *)msgp)->sp_lu[i],(Byte *)&w[0],2); d612 1 a612 1 bcopy((Byte *)&((Chem5Msg *)msgp)->ch_unused[i],(Byte *)&w[0],2); d647 1 a647 1 bcopy((Byte *)&((SpecMsg *)msgp)->sp_lu[0],(Byte *)&w[0],2); d649 1 a649 1 bcopy((Byte *)&((SpecMsg *)msgp)->sp_lu[1],(Byte *)&w[0],2); d651 1 a651 1 bcopy((Byte *)&((SpecMsg *)msgp)->sp_lu[2],(Byte *)&w[0],2); d653 1 a653 1 bcopy((Byte *)&((SpecMsg *)msgp)->sp_lu[3],(Byte *)&w[0],2); d655 1 a655 1 bcopy((Byte *)&((SpecMsg *)msgp)->sp_lu[4],(Byte *)&w[0],1); @ 3.2 log @HS2 Processing added (klh). @ text @d4 1 a4 1 /* $Header: argextract.c,v 3.0 99/05/12 10:11:30 bobh Exp $ */ d9 1 a9 1 /* $Revision: 3.0 $ */ d15 3 d592 5 a596 1 print_sensor(filenum,"%0.2x %0.2x ",w[0],w[1]); d598 5 d604 1 a604 1 print_sensor(filenum,"S"); d610 5 a614 1 print_sensor(filenum,"%0.2x %0.2x ",w[0],w[1]); d616 5 d622 1 a622 1 print_sensor(filenum,"C"); @ 3.1 log @check in prior to ARGOS_REV 5 to preserve original @ text @d100 1 d110 2 a112 1 d392 3 a394 1 year = tmPtr->tm_year + 1900; d482 13 d496 28 d570 12 d583 26 d610 29 d679 14 d694 37 d1306 19 d1326 108 d1456 4 @ 3.0 log @Added tstring, misc changes @ text @d4 1 a4 1 /* $Header: argextract.c,v 2.9 98/08/24 13:45:58 bobh Exp $ */ d9 1 a9 1 /* $Revision: 2.9 $ */ d15 3 d390 1 a390 1 year = tmPtr->tm_year; @ 2.9 log @Archiving sources after M2/M3 & Eqpac deployments of 1998 @ text @d4 1 a4 1 /* $Header: argextract.c,v 2.8 98/03/17 11:11:45 bobh Exp $ */ d9 1 a9 1 /* $Revision: 2.8 $ */ d15 3 d421 56 d532 1 a532 1 Int32 luAdr, Int32 luChan ) d546 1 a546 1 ed = decode_prr_chan( ival, &spec_cal.spc_cal[edAdr][i] ); a565 34 /* Function : printSpecRev2 */ /* Purpose : Print a PRR Spectro message (Rev 1/2) */ /* Inputs : File number, File day, Spectro message ptr, */ /* Address tags for Ed, Lu chans, Fluorometer value */ /* Outputs : None */ /************************************************************************/ Void printSpecRev2( Nat32 filenum, Flt64 day, SpecMsg *msgp, Int32 edAdr, Int32 luAdr, Int32 luChan, Flt64 fluor ) { printSpec( filenum, day, msgp, edAdr, luAdr, luChan ); print_sensor( filenum, "%9.5f\n", fluor ); } /* printSpecRev2() */ /************************************************************************/ /* Function : printSpecRev3 */ /* Purpose : Print a PRR Spectro message (Rev 3) */ /* Inputs : File number, File day, Spectro message ptr, */ /* Address tags for Ed, Lu chans, Number of addrs or errs*/ /* Outputs : None */ /************************************************************************/ Void printSpecRev3( Nat32 filenum, Flt64 day, SpecMsg *msgp, Int32 edAdr, Int32 luAdr, Int32 luChan, Nat32 extra ) { printSpec( filenum, day, msgp, edAdr, luAdr, luChan ); print_sensor( filenum, "%u\n", extra ); } /* printSpecRev3() */ /************************************************************************/ d736 66 d928 3 a930 2 printSpecRev2( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, SPEC_NOON_LU_CHAN, fluor ); d938 3 a940 2 printSpecRev2( SPEC_1030_FILE, fdate, &msgp->msg.spec0m_1030, SPEC_0M_ED, SPEC_0M_LU, SPEC_AM_LU_CHAN, fluor ); d950 3 a952 2 printSpecRev2( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, fluor ); d978 2 a979 2 /* Function : printOneMsgRev3 */ /* Purpose : Print one received ARGOS message in Rev 3 format */ d984 1 a984 1 printOneMsgRev3( ArgosInMsg *msgp ) d987 1 a987 1 Nat16 ival; d991 6 d1009 8 a1016 3 printChem( fdate, &msgp->msg.chem ); printNO3( NO3_0_FILE, fdate, &msgp->msg.chem.ch_no3 ); printTemp( TEMP0_FILE, fdate, &msgp->msg.chem.ch_no3 ); d1020 4 a1023 3 ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecRev3( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, SPEC_NOON_LU_CHAN, ival ); d1027 5 a1031 3 ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecRev3( SPEC_0M_1230_FILE, fdate, &msgp->msg.spec0m_1230, SPEC_0M_ED, SPEC_0M_LU, SPEC_1230_LU_CHAN, ival ); d1035 16 a1050 3 ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecRev3( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, ival ); d1054 16 a1069 3 ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecRev3( SPEC_20M_1230_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, ival ); d1073 3 a1075 3 ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecRev3( SPEC_0M_DARK_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, SPEC_NOON_LU_CHAN, ival ); d1079 3 a1081 3 ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc ); printSpecRev3( SPEC_20M_DARK_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, ival ); d1084 6 d1103 1 a1103 1 ival = getIntelword( (Byte *)&msgp->msg.shutter.sh_satDark[i] ); d1105 1 a1105 1 lu = decode_prr_chan( ival, NULL ); d1107 1 a1107 1 lu = decode_prr_chan( ival, d1113 9 d1125 4 a1128 1 printMiscRev3( fdate, &msgp->msg.misc3 ); d1138 1 a1138 1 } /* printOneMsgRev3() */ d1158 5 a1162 1 printOneMsgRev3( msgp ); @ 2.8 log @Archiving sources prior to porting to DOS/Windows @ text @d4 1 a4 1 /* $Header: argextract.c,v 1.1 97/10/27 09:53:19 bobh Exp $ */ d9 1 a9 1 /* $Revision: 1.1 $ */ d15 3 d26 2 a27 2 #include /* MBARI standard types */ #include /* MBARI standard constants */ d33 1 a33 1 #define SPEC_VOLTS TRUE @ 1.1 log @Initial revision @ text @d4 1 a4 1 /* $Header$ */ d9 1 a9 1 /* $Revision$ */ d14 4 a17 1 /* $Log$ a20 2 #define ARGOS_REV 2 #define SPEC_VOLTS TRUE d30 1 d465 1 a465 1 /* Address tags for Ed, Lu chans, Fluorometer value */ d470 1 a470 1 Int32 luAdr, Int32 luChan, Flt64 fluor ) d500 15 d517 1 a517 1 } /* printSpec() */ d521 17 a646 10 if ( reverseNO3 ) { printNO3( NO3_0_FILE, day, &msgp->ms_no3 ); printTemp( TEMP0_FILE, day, &msgp->ms_no3 ); } else { printNO3( NO3_20_FILE, day, &msgp->ms_no3 ); printTemp( TEMP20_FILE, day, &msgp->ms_no3 ); } d653 55 d780 2 a781 2 /* Function : printOneMsg */ /* Purpose : Print one received ARGOS messages */ d786 1 a786 1 printOneMsg( ArgosInMsg *msgp ) d830 1 a830 1 ifluor = getIntelword( (Byte *)&msgp->msg.spec0m.sp_fluor ); d834 2 a835 2 printSpec( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m, SPEC_0M_ED, SPEC_0M_LU, SPEC_NOON_LU_CHAN, fluor ); d839 1 a839 1 ifluor = getIntelword( (Byte *)&msgp->msg.spec0m.sp_fluor ); d843 2 a844 2 printSpec( SPEC_1030_FILE, fdate, &msgp->msg.spec0m_1030, SPEC_0M_ED, SPEC_0M_LU, SPEC_AM_LU_CHAN, fluor ); d848 1 a848 1 ifluor = getIntelword( (Byte *)&msgp->msg.spec0m.sp_fluor ); d854 2 a855 2 printSpec( SPEC_20_FILE, fdate, &msgp->msg.spec20m, SPEC_20M_ED, SPEC_20M_LU, 0, fluor ); d867 1 a867 1 printMisc( fdate, &msgp->msg.misc ); d876 133 @