Changeset 5054


Ignore:
Timestamp:
10/11/12 03:20:54 (6 years ago)
Author:
cochrane
Message:

Fixed a problem with saving more then one PSN Event file.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/libsrc/util/psn4putaway.c

    r2825 r5054  
    22   Created Dec 14 2005 by Larry Cochrane, Redwood City, PSN 
    33   Updated July 8 2006 - Replaced TRACE_HEADER with TRACE2_HEADER 
     4   Updated Jan 26 2012 - Fixed problem with saving more then one file  
    45 */ 
    56 
     
    1718#include <pa_subs.h> 
    1819#include <time_ew.h> 
     20#include <math.h> 
     21 
     22#ifndef WIN32 
     23#define WORD unsigned short 
     24#define BYTE unsigned char 
     25#define UINT unsigned int                       // needs to be 4 bytes 
     26#endif 
     27 
    1928#include <psn4putaway.h> 
    20 #include <math.h> 
    21  
    22 static char *DataloggerString = "Earthworm 7.0"; 
     29 
     30static char *DataloggerString = "Earthworm 7.x"; 
    2331 
    2432static PSNType4 PsnHeader;              /* header that get saves to disk */ 
     
    2634static short *BufferShort = 0;  /* write out data as short integers */ 
    2735static float *BufferFloat = 0;  /* write out data as float */ 
    28 static FILE *PsnFile = 0;               /* file pointer used to write out event file */ 
    29 static char FileName[256];              /* holds the file name we will be using */ 
    30 static char SaveDir[256];               /* holds the directory we wil be using */ 
     36static char FileNameRoot[256];          /* holds the file name we will be using */ 
     37static char SaveDir[256];               /* holds the directory we will be using */ 
    3138static int GoodData = 0;                /* used to check for deleting empty file */ 
    3239static char StaLocation[256];   /* station location string */ 
     
    8996int PSN4PA_next_ev( TRACE_REQ *ptrReq, char *EventDate, char *EventTime, int debug ) 
    9097{ 
    91         char toDir[256], fname[256]; 
    92  
     98        char toDir[ 256 ]; 
     99         
    93100        sprintf( toDir, "%s\\%-4.4s", SaveDir, &EventDate[2] ); 
    94101        CreateDir( toDir ); 
    95102 
    96         sprintf( fname, "%s\\%-6.6s.%-6.6s.%s.%s.psn", toDir, &EventDate[2], EventTime, 
    97                 ptrReq->sta, ptrReq->chan ); 
    98  
    99         if( debug == 1 ) 
    100                 logit ("t", "Opening PSN Type 4 file %s\n", fname ); 
    101  
    102         if( ! ( PsnFile = fopen( fname, "w+b" ) ) )  { 
    103                 logit ("et", "PSN4PA_init: couldn't open output file %s\n", fname ); 
    104                 return EW_FAILURE; 
    105         } 
    106         strcpy( FileName, fname ); 
     103        sprintf( FileNameRoot, "%s\\%-6.6s.%-6.6s", toDir, &EventDate[2], EventTime ); 
     104                 
     105        if( debug ) 
     106                logit ("t", "PSN 4 Root File Name %s\n", FileNameRoot ); 
     107 
    107108        GoodData = 0; 
    108109        return(EW_SUCCESS); 
     
    133134        double samprate; 
    134135        long fill = 0l; 
    135         char scnl[80]; 
     136        char scnl[80], fname[ 256 ]; 
    136137        double min, max, mean; 
    137138        int len, varLen, crcLen; 
     
    139140        int swap = FALSE; 
    140141        WORD crc; 
     142        FILE *psnFile = 0;              /* file pointer used to write out event file */ 
    141143 
    142144#if defined (_SPARC) 
     
    146148        /* Check arguments */ 
    147149        if( getThis == NULL )  { 
    148                 logit ("e", "PSN4PA_next: invalid argument passed in.\n"); 
     150                logit ("et", "PSN4PA_next: invalid argument passed in.\n"); 
    149151                return EW_FAILURE; 
    150152        } 
     
    153155 
    154156        if( (msg_p = getThis->pBuf) == NULL )  {         /* pointer to first message */ 
    155                 logit ("e", "PSN4PA_next: Message buffer is NULL.\n"); 
     157                logit ("et", "PSN4PA_next: Message buffer is NULL.\n"); 
    156158                return EW_FAILURE; 
    157159        } 
    158160        wf = (TRACE2_HEADER *)msg_p; 
    159161 
     162        if( !strncmp( wf->loc, "--", 2 ) || !strncmp( wf->loc, "NC", 2 ) ) 
     163                sprintf( fname, "%s.%s.%s.%s.PSN", FileNameRoot, wf->sta, wf->chan, wf->net ); 
     164        else 
     165                sprintf( fname, "%s.%s.%s.%s.%s.PSN", FileNameRoot, wf->sta, wf->chan, wf->net, wf->loc ); 
     166        if( debug == 1 ) 
     167                logit ("t", "Opening PSN Type 4 file %s\n", fname ); 
     168 
     169        if( ! ( psnFile = fopen( fname, "w+b" ) ) )  { 
     170                logit ("et", "PSN4PA_init: couldn't open output file %s\n", fname ); 
     171                return EW_FAILURE; 
     172        } 
     173         
    160174        /* Look at the first TRACE2_HEADER and get set up of action */ 
    161175        if (WaveMsg2MakeLocal(wf) < 0)  { 
    162                 logit("e", "PSN4PA_next: unknown trace data type: %s\n", wf->datatype); 
     176                logit("et", "PSN4PA_next: unknown trace data type: %s\n", wf->datatype); 
     177                fclose( psnFile ); 
    163178                return( EW_FAILURE ); 
    164179        } 
     
    170185                logit("et", "unreasonable sample rate (%f) for <%s.%s.%s>\n", samprate, 
    171186                        wf->sta, wf->chan, wf->net); 
     187                fclose( psnFile ); 
    172188                return( EW_FAILURE ); 
    173189        } 
     
    185201        if (datatype == 'n')  { 
    186202                logit("et", "PSN4PA_next: unsupported datatype: %s\n", datatype); 
     203                fclose( psnFile ); 
    187204                return( EW_FAILURE ); 
    188205        } 
     
    204221                this_size = (nsamp_this_scnl + nsamp ) * sizeof(long); 
    205222                if ( OutBufferLen < this_size )  { 
    206                         logit( "e", "out of space for <%s.%s.%s>; saving long trace.\n", 
     223                        logit( "et", "out of space for <%s.%s.%s>; saving long trace.\n", 
    207224                                 wf->sta, wf->chan, wf->net); 
    208225                        break; 
     
    261278                wf = (TRACE2_HEADER *) msg_p; 
    262279                if (WaveMsg2MakeLocal(wf) < 0)  { 
    263                         logit("e", "PSN4PA_next: unknown trace data type: %s\n", 
     280                        logit("et", "PSN4PA_next: unknown trace data type: %s\n", 
    264281                                                wf->datatype); 
     282                        fclose( psnFile ); 
    265283                        return( EW_FAILURE ); 
    266284                } 
     
    271289                if ( endtime + ( 1.0/samprate ) * GapThresh < starttime ) { 
    272290                        /* there's a gap, so fill it */ 
    273                         logit("e", "gap in %s.%s.%s: %lf: %lf\n", wf->sta, wf->chan, wf->net, 
     291                        logit("et", "gap in %s.%s.%s: %lf: %lf\n", wf->sta, wf->chan, wf->net, 
    274292                                                endtime, starttime - endtime); 
    275293                        nfill = (long) (samprate * (starttime - endtime) - 1); 
    276294                        if ( (nsamp_this_scnl + nfill) * (long)sizeof(long) > OutBufferLen ) { 
    277                                 logit("e", 
    278                                                         "bogus gap (%d); skipping\n", nfill); 
     295                                logit("et", "bogus gap (%d); skipping\n", nfill); 
     296                                fclose( psnFile ); 
    279297                                return(EW_FAILURE); 
    280298                        } 
     
    361379 
    362380        /* now write the main header */ 
    363         if( fwrite( (void *)hdr, 1, sizeof(PSNType4), PsnFile ) != sizeof(PSNType4) )  { 
     381        if( fwrite( (void *)hdr, 1, sizeof(PSNType4), psnFile ) != sizeof(PSNType4) )  { 
    364382                logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
     383                fclose( psnFile ); 
    365384                return EW_FAILURE; 
    366385        } 
     
    374393                if( swap ) 
    375394                        SwapPsnVarHeader( &varHdr ); 
    376                 if(fwrite(&varHdr, 1, sizeof(VarHeader), PsnFile ) != (UINT)sizeof(VarHeader) )  { 
     395                if(fwrite(&varHdr, 1, sizeof(VarHeader), psnFile ) != (UINT)sizeof(VarHeader) )  { 
    377396                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
    378                         return EW_FAILURE; 
    379                 } 
    380                 if(fwrite( StaLocation, 1, len, PsnFile ) != (UINT)len )  { 
     397                        fclose( psnFile ); 
     398                        return EW_FAILURE; 
     399                } 
     400                if(fwrite( StaLocation, 1, len, psnFile ) != (UINT)len )  { 
    381401                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
     402                        fclose( psnFile ); 
    382403                        return EW_FAILURE; 
    383404                } 
     
    391412                if( swap ) 
    392413                        SwapPsnVarHeader( &varHdr ); 
    393                 if(fwrite(&varHdr, 1, sizeof(VarHeader), PsnFile ) != (UINT)sizeof(VarHeader) )  { 
     414                if(fwrite(&varHdr, 1, sizeof(VarHeader), psnFile ) != (UINT)sizeof(VarHeader) )  { 
    394415                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
    395                         return EW_FAILURE; 
    396                 } 
    397                 if( fwrite( SensorInfo, 1, len, PsnFile ) != (UINT)len )  { 
     416                        fclose( psnFile ); 
     417                        return EW_FAILURE; 
     418                } 
     419                if( fwrite( SensorInfo, 1, len, psnFile ) != (UINT)len )  { 
    398420                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
     421                        fclose( psnFile ); 
    399422                        return EW_FAILURE; 
    400423                } 
     
    408431                if( swap ) 
    409432                        SwapPsnVarHeader( &varHdr ); 
    410                 if(fwrite(&varHdr, 1, sizeof(VarHeader), PsnFile ) != (UINT)sizeof(VarHeader) )  { 
     433                if(fwrite(&varHdr, 1, sizeof(VarHeader), psnFile ) != (UINT)sizeof(VarHeader) )  { 
    411434                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
    412                         return EW_FAILURE; 
    413                 } 
    414                 if( fwrite( DataloggerString, 1, len, PsnFile ) != (UINT)len )  { 
     435                        fclose( psnFile ); 
     436                        return EW_FAILURE; 
     437                } 
     438                if( fwrite( DataloggerString, 1, len, psnFile ) != (UINT)len )  { 
    415439                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
     440                        fclose( psnFile ); 
    416441                        return EW_FAILURE; 
    417442                } 
     
    425450                if( swap ) 
    426451                        SwapPsnVarHeader( &varHdr ); 
    427                 if(fwrite(&varHdr, 1, sizeof(VarHeader), PsnFile ) != sizeof( VarHeader ) )  { 
     452                if(fwrite(&varHdr, 1, sizeof(VarHeader), psnFile ) != sizeof( VarHeader ) )  { 
    428453                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
     454                        fclose( psnFile ); 
    429455                        return EW_FAILURE; 
    430456                } 
     
    432458                        SwapChanInfo( &ChanInfo ); 
    433459 
    434                 if( fwrite( &ChanInfo, 1, sizeof( ChannelInfo ), PsnFile ) != sizeof( ChannelInfo ) )  { 
     460                if( fwrite( &ChanInfo, 1, sizeof( ChannelInfo ), psnFile ) != sizeof( ChannelInfo ) )  { 
    435461                        logit ("et", "PSN4PA_next: error writing PSN4 Header. \n"); 
     462                        fclose( psnFile ); 
    436463                        return EW_FAILURE; 
    437464                } 
     
    455482 
    456483        if( datatype == 's' )  { 
    457                 if ((long)fwrite ((void *) BufferShort, sizeof (char), data_size, PsnFile ) != 
     484                if ((long)fwrite ((void *) BufferShort, sizeof (char), data_size, psnFile ) != 
    458485                                data_size )  { 
    459486                        logit ("et", "PSN4PA_next: error writing short TRACE data. \n"); 
     487                        fclose( psnFile ); 
    460488                        return EW_FAILURE; 
    461489                } 
    462490        } 
    463491        else if( datatype == 'l' ) { 
    464                 if( (long)fwrite ((void *) BufferLong, sizeof (char), data_size, PsnFile ) != 
     492                if( (long)fwrite ((void *) BufferLong, sizeof (char), data_size, psnFile ) != 
    465493                                data_size )  { 
    466494                        logit ("et", "PSN4PA_next: error writing long TRACE data. \n"); 
     495                        fclose( psnFile ); 
    467496                        return EW_FAILURE; 
    468497                } 
    469498        } 
    470499        else  {         // write out float data 
    471                 if( (long)fwrite ((void *) BufferFloat, sizeof (char), data_size, PsnFile ) != 
     500                if( (long)fwrite ((void *) BufferFloat, sizeof (char), data_size, psnFile ) != 
    472501                                data_size )  { 
    473502                        logit ("et", "PSN4PA_next: error writing long TRACE data. \n"); 
     503                        fclose( psnFile ); 
    474504                        return EW_FAILURE; 
    475505                } 
    476506        } 
    477507 
    478         crc = CalcFileCRC( PsnFile, crcLen ); 
     508        crc = CalcFileCRC( psnFile, crcLen ); 
    479509        if( swap ) 
    480510                SwapShort( &crc ); 
    481         if( fwrite(&crc, 1, sizeof(short), PsnFile ) != sizeof(short)) 
     511        if( fwrite(&crc, 1, sizeof(short), psnFile ) != sizeof(short)) 
    482512                logit ("et", "PSN4PA_next: error writing crc. \n"); 
    483513        GoodData = TRUE; 
     514        fclose( psnFile ); 
    484515        return EW_SUCCESS; 
    485516} 
     
    491522int PSN4PA_end_ev(int debug) 
    492523{ 
    493         if( debug == 1 ) 
    494                         logit("t", "Closing PSN Type 4 file \n"); 
    495         if( PsnFile ) 
    496                 fclose( PsnFile ); 
    497         PsnFile = 0; 
    498         if( !GoodData ) 
    499                 unlink( FileName ); 
    500524        return(EW_SUCCESS); 
    501525} 
     
    547571 
    548572        StaLocation[0] = SensorInfo[0] = 0; 
    549         ChanInfo.sensorOutVolt = ChanInfo.ampGain = ChanInfo.adcInputVolt; 
     573        ChanInfo.sensorOutVolt = ChanInfo.ampGain = ChanInfo.adcInputVolt = 0; 
    550574 
    551575        if( debug ) 
    552                 logit("", "Start ReadStationFile - Looking for %s\n", scnl ); 
     576                logit("t", "Start ReadStationFile - Looking for %s\n", scnl ); 
    553577 
    554578        if( !dir )  { 
    555579                if( debug == 1 ) 
    556                         logit("e", "Environment variable EW_PARAMS not found\n"); 
     580                        logit("et", "Environment variable EW_PARAMS not found\n"); 
    557581                return; 
    558582        } 
     
    562586        if( ! (fp = fopen( fname, "r" ) ) )  { 
    563587                if( debug == 1 ) 
    564                         logit("e", "Station information file %s not found\n", fname ); 
     588                        logit("et", "Station information file %s not found\n", fname ); 
    565589                return; 
    566590        } 
     
    581605                fclose( fp ); 
    582606                if( debug ) 
    583                         logit("e", "Station information not found\n" ); 
     607                        logit("et", "Station information not found\n" ); 
    584608                return; 
    585609        } 
    586610 
    587611        if( debug ) 
    588                 logit("e", "Station information found\n" ); 
     612                logit("et", "Station information found\n" ); 
    589613 
    590614        /* We found the SCNL so now get the key=data pairs from the file */ 
     
    654678                        continue; 
    655679                } 
    656                 if( !strcmp( key, "sensorInformation" ) )  { 
     680                if( !strcmp( key, "sensorinformation" ) )  { 
    657681                        strcpy( SensorInfo, data ); 
    658682                        continue; 
     
    690714        strcpy( key, string );                  // get the key 
    691715        Strib( key ); 
    692         strlwr( key ); 
     716        _strlwr( key ); 
    693717        ++ptr; 
    694718        ptr = SkipSpace( ptr ); 
     
    780804                cnt = fread( buff, 1, len, fp ); 
    781805                if( !cnt ) 
    782                         logit("e", "Error calculating PSN file CRC. Read error\n"); 
     806                        logit("et", "Error calculating PSN file CRC. Read error\n"); 
    783807                CalcCRC16( &crc, buff, cnt ); 
    784808                length -= len; 
Note: See TracChangeset for help on using the changeset viewer.