head     2.9;
access   ;
symbols  ;
locks    ; strict;
comment  @ * @;


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
@


2.9
log
@Archiving sources after M2/M3 & Eqpac deployments of 1998
@
text
@/************************************************************************/
/* Copyright 1997 MBARI							*/
/************************************************************************/
/* $Header: argextract.c,v 2.8 98/03/17 11:11:45 bobh Exp $		    */
/* Summary  : Program to extract data files from ARGOS data		*/
/* Filename : argextract.c						*/
/* Author   : Bob Herlien (rah)						*/
/* Project  : OASIS							*/
/* $Revision: 2.8 $							    */
/* Created  : 13 Jan 1997 from argos.c					*/
/************************************************************************/
/* Modification History:						*/
/* 13jan97 rah - created from argos.c					*/
/* $Log:	argextract.c,v $
 * 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 <stdio.h>			/* Unix standard I/O		*/
#include <stdlib.h>			/* Unix standard library	*/
#include <mbariTypes.h>			/* MBARI standard types		*/
#include <mbariConst.h>			/* MBARI standard constants	*/
#include <time.h>			/* Unix time library		*/
#include <decode.h>			/* OASIS data definitions	*/
#include <string.h>			/* Unix string library		*/
#include <argos.h>			/* 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 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;				/********************************/


/********************************/
/*	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 );


/********************************/
/*	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*/


/********************************/
/*	Module Local Data	*/
/********************************/

MLocal char		*cfgp = NULL;	/* Ptr to name of OASIS config file */
MLocal MBool		decode_all = TRUE;
MLocal MBool		decode_msg[NUM_MSG_TYPES];

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 };


/********************************/
/*	Forward Declarations	*/
/********************************/

MBool	processCommandLine ( Int32 argc, char **argv );
Void	decodeFile( char *filename );
Void	printOneMsg( ArgosInMsg *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 );
    }

} /* 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" );
    fprintf( stderr, "-c specifies a configuration file\n" );
    fprintf( stderr, "-i decodes a specified message 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;

    for ( i = 0; i < NUM_MSG_TYPES; i++ )
	decode_msg[i] = FALSE;

    while ( (c = getopt(argc, argv, "c:i:")) != EOF )
	switch( c )
	{
	  case 'c':
	    cfgp = optarg;
	    break;

	  case 'i':
	    decode_all = FALSE;
	    decode_msg[atoi(optarg)] = TRUE;
	    break;

	  default:
	    use_msg( argv[0] );
	    return( FALSE );
	}

    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;

    buffer[0] = '\0';

    while( TRUE )
    {
	if ( fgets(buffer, BUFSIZE, fp) == NULL )
	    return( END_OF_FILE );

	if ( (len = strlen(buffer)) > 0 )
	{
	    if ( buffer[len] == '\n' )
		buffer[len] = '\0';
	    return( MSG_OK );
	}
    }

} /* 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    : 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;

	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++;
	    }
	}
    }

} /* 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;
    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    : 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    : 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 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] );
#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    : 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() */


/************************************************************************/
/* 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	i, 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    : 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;
	printSpecRev2( SPEC_NOON_FILE, fdate, &msgp->msg.spec0m,
		      SPEC_0M_ED, SPEC_0M_LU, SPEC_NOON_LU_CHAN, 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;
	printSpecRev2( SPEC_1030_FILE, fdate, &msgp->msg.spec0m_1030,
		       SPEC_0M_ED, SPEC_0M_LU, SPEC_AM_LU_CHAN, 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
	printSpecRev2( SPEC_20_FILE, fdate, &msgp->msg.spec20m,
		       SPEC_20M_ED, SPEC_20M_LU, 0, 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					*/
/* Purpose     : Print one received ARGOS message in Rev 3 format	*/
/* Inputs      : Message Pointer					*/
/* Outputs     : None							*/
/************************************************************************/
	Void
printOneMsgRev3( ArgosInMsg *msgp )
{
    Nat32	msgType;
    Nat16	ival;
    Reg Nat32	i;
    Flt64	fdate, lu;
    
    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 );
	printNO3( NO3_0_FILE, fdate, &msgp->msg.chem.ch_no3 );
	printTemp( TEMP0_FILE, fdate, &msgp->msg.chem.ch_no3 );
	break;

      case SPEC_0M_NOON:
	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 );
	break;

      case SPEC_0M_1230:
	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 );
	break;

      case SPEC_20M:
	ival = getIntelword( (Byte *)&msgp->msg.spec0m.sp_misc );
	printSpecRev3( SPEC_20_FILE, fdate, &msgp->msg.spec20m,
		       SPEC_20M_ED, SPEC_20M_LU, 0, ival );
	break;

      case SPEC_20M_1230:
	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 );
	break;

      case SPEC_0M_DARK:
	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 );
	break;

      case SPEC_20M_DARK:
	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 );
	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++ )
	{
	    ival = getIntelword( (Byte *)&msgp->msg.shutter.sh_satDark[i] );
#if SPEC_VOLTS
	    lu = decode_prr_chan( ival, NULL );
#else
	    lu = decode_prr_chan( ival,
			 &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" );
	break;

      case MISC:
	printMiscRev3( fdate, &msgp->msg.misc3 );
	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() */


/************************************************************************/
/* 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( msgp );
	break;

      default:
	printf( "Bad software revision number %d\n", revision );
    }

} /* 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() */
@


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/types.h>		/* MBARI standard types		*/
#include <mbari/const.h>		/* 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
@