Changeset 8323


Ignore:
Timestamp:
02/16/21 10:46:45 (8 weeks ago)
Author:
kevin
Message:

Added TYPE_LATENCY_SCNL_BIN support

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/latency_scnl.h

    r8298 r8323  
    88#define LATENCY_SCNL_H 
    99 
     10#include <stdio.h> 
     11#include <string.h> 
    1012#include "strfuncs.h" 
    1113#include "trace_buf.h" 
     14#define SEED_STA_LEN  5  // station without terminating NULL 
     15#define SEED_NET_LEN  2  // network without terminating NULL 
     16#define SEED_CHAN_LEN 3  // channel without terminating NULL 
     17#define SEED_LOC_LEN  2  // location without terminating NULL 
     18 
     19#define SEED_STA_STR_LEN  (SEED_STA_LEN + 1)   // station with terminating NULL 
     20#define SEED_NET_STR_LEN  (SEED_NET_LEN + 1)   // network with terminating NULL 
     21#define SEED_CHAN_STR_LEN (SEED_CHAN_LEN + 1)  // channel with terminating NULL 
     22#define SEED_LOC_STR_LEN  (SEED_LOC_LEN + 1)   // location with terminating NULL 
    1223 
    1324// maximum number of digits in a long integer (NULL-terminated) 
     
    1627#define INT_LEN 12 
    1728 
     29// latency SCNL information (with terminating NULL characters) 
     30typedef struct _LATENCY_SCNL_INFO { 
     31  double starttime;             /* time of first sample in epoch seconds 
     32                                   (seconds since midnight 1/1/1970) */ 
     33  double endtime;               /* Time of last sample in epoch seconds */ 
     34  char sta[SEED_STA_STR_LEN];   /* Site name (NULL-terminated) */ 
     35  char net[SEED_NET_STR_LEN];   /* Network name (NULL-terminated) */ 
     36  char chan[SEED_CHAN_STR_LEN]; /* Component/channel code (NULL-terminated)*/ 
     37  char loc[SEED_LOC_STR_LEN];   /* Location code (NULL-terminated) */ 
     38  int latency;                  /* Latency in milliseconds */ 
     39} LATENCY_SCNL_INFO; 
     40 
     41// latency SCNL binary (without terminating NULL characters) 
    1842typedef struct _LATENCY_SCNL_BIN { 
    1943  double starttime;           /* time of first sample in epoch seconds 
    20                                (seconds since midnight 1/1/1970) */ 
     44                                 (seconds since midnight 1/1/1970) */ 
    2145  double endtime;             /* Time of last sample in epoch seconds */ 
    22   char sta[TRACE2_STA_LEN];   /* Site name (NULL-terminated) */ 
    23   char net[TRACE2_NET_LEN];   /* Network name (NULL-terminated) */ 
    24   char chan[TRACE2_CHAN_LEN]; /* Component/channel code (NULL-terminated)*/ 
    25   char loc[TRACE2_LOC_LEN];   /* Location code (NULL-terminated) */ 
     46  char sta[SEED_STA_LEN];     /* Site name (NULL-terminated) */ 
     47  char net[SEED_NET_LEN];     /* Network name (NULL-terminated) */ 
     48  char chan[SEED_CHAN_LEN];  /* Component/channel code (NULL-terminated)*/ 
     49  char loc[SEED_LOC_LEN];     /* Location code (NULL-terminated) */ 
    2650  int latency;                /* Latency in milliseconds */ 
    2751} LATENCY_SCNL_BIN; 
    2852 
    29 typedef struct _LATENCY_SCNL { 
    30   char starttime[LONG_LEN];   /* time of first sample in epoch milliseconds 
    31                                (milliseconds since midnight 1/1/1970) */ 
    32   char endtime[LONG_LEN];     /* Time of last sample in epoch milliseconds */ 
    33   char sta[TRACE2_STA_LEN];   /* Site name (NULL-terminated) */ 
    34   char net[TRACE2_NET_LEN];   /* Network name (NULL-terminated) */ 
    35   char chan[TRACE2_CHAN_LEN]; /* Component/channel code (NULL-terminated)*/ 
    36   char loc[TRACE2_LOC_LEN];   /* Location code (NULL-terminated) */ 
    37   char latency[INT_LEN];      /* Latency in milliseconds */ 
    38 } LATENCY_SCNL; 
     53// latency SCNL as text 
     54typedef struct _LATENCY_SCNL_TEXT { 
     55  char starttime[LONG_LEN];     /* time of first sample in epoch milliseconds 
     56                                   (milliseconds since midnight 1/1/1970) */ 
     57  char endtime[LONG_LEN];       /* Time of last sample in epoch milliseconds */ 
     58  char sta[SEED_STA_STR_LEN];   /* Site name (NULL-terminated) */ 
     59  char net[SEED_NET_STR_LEN];   /* Network name (NULL-terminated) */ 
     60  char chan[SEED_CHAN_STR_LEN]; /* Component/channel code (NULL-terminated)*/ 
     61  char loc[SEED_LOC_STR_LEN];   /* Location code (NULL-terminated) */ 
     62  char latency[INT_LEN];        /* Latency in milliseconds */ 
     63} LATENCY_SCNL_TEXT; 
    3964 
    40 // convert LATENCY_SCNL to a single string 
    41 #define LATENCY_SCNL_TO_STRING(L)                                              \ 
    42   strreplace((L)->starttime, sizeof(struct _LATENCY_SCNL) - 1, '\0', ' ') 
    43  
    44 // convert LATENCY_SCNL to separate strings in struct 
    45 #define LATENCY_SCNL_TO_STRUCT(L)                                              \ 
    46   strreplace((L)->starttime, sizeof(struct _LATENCY_SCNL) - 1, ' ', '\0') 
     65/** Latency String size  */ 
     66#define LATENCY_STR_SIZE (sizeof(LATENCY_SCNL_TEXT)) 
    4767 
    4868/** 
    49  * Convert LATENCY_SCNL to LATENCY_SCNL_BIN 
    50  * @param latency_scnl the LATENCY_SCNL 
     69 * Convert LATENCY_SCNL_TEXT to LATENCY_SCNL 
     70 * @param latency_scnl_text the LATENCY_SCNL_TEXT 
     71 * @param latency_scnl_info  the LATENCY_SCNL_INFO 
     72 */ 
     73void latencyscnltext2info(LATENCY_SCNL_TEXT *latency_scnl_text, 
     74                          LATENCY_SCNL_INFO *latency_scnl_info); 
     75/** 
     76 * Convert LATENCY_SCNL_INFO to LATENCY_SCNL_BIN 
     77 * @param latency_scnl_info the LATENCY_SCNL_INFO 
    5178 * @param latency_scnl_bin the LATENCY_SCNL_BIN 
    5279 */ 
    53 void latencyscnl2bin(LATENCY_SCNL *latency_scnl, 
     80void latencyscnlinfo2bin(LATENCY_SCNL_INFO *latency_scnl_info, 
     81                         LATENCY_SCNL_BIN *latency_scnl_bin); 
     82 
     83/** 
     84 * Convert LATENCY_SCNL_BIN to LATENCY_SCNL_INFO 
     85 * @param latency_scnl_bin the LATENCY_SCNL_BIN 
     86 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     87 */ 
     88void latencyscnlbin2info(LATENCY_SCNL_BIN *latency_scnl_bin, 
     89                         LATENCY_SCNL_INFO *latency_scnl_info); 
     90 
     91/** 
     92 * Parse the line of latency text. 
     93 * @param latency_scnl_text the LATENCY_SCNL_TEXT 
     94 * @param line the line 
     95 * @return the number of  input items successfully matched and assigned (normally 7) or -1 if EOF 
     96 */ 
     97int parselatencytext(LATENCY_SCNL_TEXT *latency_scnl_text, char *line); 
     98 
     99/** 
     100 * Read the latency binary packet. 
     101 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     102 * @param fp the file pointer 
     103 * @return 0 if success, -1 if EOF, positive number if error. 
     104 */ 
     105int read_latency_bin(LATENCY_SCNL_INFO *latency_scnl_info, FILE *fp); 
     106 
     107/** 
     108 * Read the latency text packet. 
     109 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     110 * @param fp the file pointer 
     111 * @return 0 if success, -1 if EOF, positive number if error. 
     112 */ 
     113int read_latency_text(LATENCY_SCNL_INFO *latency_scnl_info, FILE *fp); 
     114 
     115/** 
     116 * Convert TBUF2 to LATENCY_SCNL_BIN 
     117 * @param trh the TRACE2_HEADER 
     118 * @param latency the latency 
     119 * @param latency_scnl_bin the LATENCY_SCNL_BIN 
     120 */ 
     121void tbuf2latencybin(TRACE2_HEADER *trh, int latency, 
    54122                     LATENCY_SCNL_BIN *latency_scnl_bin); 
    55123 
     124/** 
     125 * Convert the TBUF2 to text. 
     126 * @param trh the TRACE2_HEADER 
     127 * @param latency the latency 
     128 * @param str the string which should large enough to hold LATENCY_STR_SIZE characters 
     129 * @param fixed non-zero if fixed size 
     130 */ 
     131void tbuf2latencystr(TRACE2_HEADER *trh, int latency, char *str, int fixed); 
     132 
     133/** 
     134 * Write the latency information. 
     135 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     136 * @param fp the file pointer 
     137 * @param dateFormat date format, 0 for epoch, 1 for GMT, 2 for local 
     138 */ 
     139void write_latency(LATENCY_SCNL_INFO *latency_scnl_info, FILE *fp, int dateFormat); 
     140 
    56141#endif 
  • trunk/src/archiving/ringplayer/config.c

    r8314 r8323  
    1212  char timestr[DATESTR_MAX]; 
    1313  int retcode = 0; 
    14   if (strcmp(com, "Debug") == 0) { 
     14  if (strcmp(com, "Binary") == 0) { 
     15    if (value) { 
     16      params->Binary = atoi(value); 
     17      if (params->Binary) 
     18        logit("o", "Binary=%d\n", params->Binary); 
     19    } 
     20  } else if (strcmp(com, "Debug") == 0) { 
    1521    if (value) { 
    1622      params->Debug = atoi(value); 
  • trunk/src/archiving/ringplayer/config.h

    r8312 r8323  
    1212 
    1313typedef struct { 
     14  int Binary; 
    1415  int Debug; 
    1516  char Latencyfile[PATH_MAX]; 
  • trunk/src/archiving/ringplayer/fileassembler.c

    r8317 r8323  
    1010#include <string.h> 
    1111 
    12 #define VERSION "1.0 - 2021-01-15" 
     12#define VERSION "1.1 - 2021-02-16" 
    1313 
    1414#define MAX_TRACEBUF_NSAMP                                                     \ 
     
    2424static int *pdata = (int *)(buffer + sizeof(Header) + sizeof(TRACE2_HEADER)); 
    2525static int linenum; 
    26 static LATENCY_SCNL latency_scnl; 
     26static LATENCY_SCNL_INFO latency_scnl_info; 
    2727 
    2828/** 
     
    105105/** 
    106106 * Process the SCNL entry. 
    107  * @param latency_scnl_bin the latency SCNL binary 
     107 * @param latency_scnl the latency SCNL 
    108108 * @param entry the SCNL entry from the SCNL table 
    109109 * @param outputfile the output file 
    110  * @return 0 if sucess or ignored, non-zero if error. 
    111  */ 
    112 static int processSCNLentry(LATENCY_SCNL latency_scnl, SCNL_ENTRY *entry, 
     110 * @return 0 if sucess, positive number if error. 
     111 */ 
     112static int processSCNLentry(LATENCY_SCNL_INFO latency_scnl, SCNL_ENTRY *entry, 
    113113                            char *outputfile) { 
    114114  MSDATA *const msdata = &sampledata; 
     
    121121  int retcode = 0; 
    122122 
    123   starttime = atol(latency_scnl.starttime) / 1000.; 
     123  starttime = latency_scnl.starttime; 
    124124  if (latency_scnl.starttime == latency_scnl.endtime) { 
    125125    endtime = starttime + params.LatencyInterval; 
    126126  } else { 
    127     endtime = atol(latency_scnl.endtime) / 1000.; 
     127    endtime = latency_scnl.endtime; 
    128128  } 
    129129 
     
    142142  } 
    143143 
    144   latency = atoi(latency_scnl.latency); 
     144  latency = latency_scnl.latency; 
    145145 
    146146  if (entry) { // if entry was provided 
     
    166166          latency_scnl.sta, latency_scnl.net, latency_scnl.loc, 
    167167          latency_scnl.chan); 
    168     return -7; 
     168    return 1; 
    169169  } 
    170170 
     
    177177          latency_scnl.sta, latency_scnl.net, latency_scnl.loc, 
    178178          latency_scnl.chan); 
    179     return -8; 
     179    return 2; 
    180180  } 
    181181  nsamp = getnsamp(starttime, endtime, msdata->delta); 
     
    183183    logit("e", "nsamp (%d) is larger than max (%d)\n", nsamp, 
    184184          MAX_TRACEBUF_NSAMP); 
    185     return -9; 
     185    return 3; 
    186186  } 
    187187 
     
    240240  if (outfp == NULL) { 
    241241    logit("e", "could not open file (%s): %s\n", outputfile, strerror(errno)); 
    242     return -9; 
     242    return 4; 
    243243  } 
    244244  // write to the output file 
     
    255255 * @param latency_scnl the latency SCNL 
    256256 * @param outputfile the output file 
    257  * @return 0 if sucess or ignored, non-zero if error. 
    258  */ 
    259 static int processSCNL(LATENCY_SCNL latency_scnl, char *outputfile) { 
     257 * @return 0 if sucess or ignored, positive number if error. 
     258 */ 
     259static int processSCNL(LATENCY_SCNL_INFO latency_scnl, char *outputfile) { 
    260260  int i; 
    261261  int retcode = 0; 
     
    285285            latency_scnl.sta, latency_scnl.chan, latency_scnl.net, 
    286286            latency_scnl.loc); 
    287       retcode = -6; 
     287      retcode = 1; 
    288288      return retcode; 
    289289    } 
     
    313313            latency_scnl.sta, latency_scnl.chan, latency_scnl.net, 
    314314            latency_scnl.loc); 
    315       retcode = -6; 
     315      retcode = 2; 
    316316      return retcode; 
    317317    } 
     
    326326 * @param latencyfile the latency file 
    327327 * @param outputfile the output file 
    328  * @return 0 if sucess or ignored, non-zero if error. 
     328 * @return 0 if sucess or ignored, positive number if error. 
    329329 */ 
    330330static int processLatencyL1Z(char *latencyfile, char *outputfile) { 
     
    346346 * @param latencyfile the latency file 
    347347 * @param outputfile the output file 
    348  * @return 0 if sucess or ignored, non-zero if error. 
    349  */ 
    350 static int processLatencyScnlFile(char *latencyfile, char *outputfile) { 
     348 * @return 0 if success, -1 if EOF, positive number if error. 
     349 */ 
     350static int processLatencyScnlFileBin(char *latencyfile, char *outputfile) { 
    351351  MSDATA *const msdata = &sampledata; 
    352352  int retcode = 0; 
    353   int i, len; 
     353  FILE *infp; 
     354   
     355  clearSampleData(); 
     356   
     357  // read the input file 
     358  infp = fopen(latencyfile, "rb"); 
     359  if (infp == NULL) { 
     360    logit("e", "could not open file (%s): %s\n", latencyfile, strerror(errno)); 
     361    retcode = errno; 
     362    return retcode; 
     363  } 
     364   
     365  for (linenum = 1;; linenum++) { 
     366    freeMsdata(msdata); // free previous data if needed 
     367    retcode = read_latency_bin(&latency_scnl_info, infp); 
     368    if (retcode) { 
     369        if (retcode < 0) 
     370        { 
     371          break; 
     372        } 
     373        logit("e", "could not read latency packet %d (%s)\n", linenum, 
     374              strerror(retcode)); 
     375        break; 
     376    } 
     377    if (params.Debug) 
     378    { 
     379      write_latency(&latency_scnl_info, stdout, 1); 
     380    } 
     381    retcode = processSCNL(latency_scnl_info, outputfile); 
     382  } // end for line 
     383  fclose(infp); 
     384  freeMsdata(msdata); 
     385  return retcode; 
     386} 
     387 
     388/** 
     389 * Process the latency from latency SCNL file 
     390 * @param latencyfile the latency file 
     391 * @param outputfile the output file 
     392 * @return 0 if success, -1 if EOF, positive number if error. 
     393 */ 
     394static int processLatencyScnlFileText(char *latencyfile, char *outputfile) { 
     395  MSDATA *const msdata = &sampledata; 
     396  int retcode = 0; 
    354397  FILE *infp; 
    355398 
     
    359402  infp = fopen(latencyfile, "r"); 
    360403  if (infp == NULL) { 
    361     logit("e", "could not open file (%s): %s\n", latencyfile, strerror(errno)); 
    362     retcode = -1; 
     404    if (errno) { 
     405      retcode = errno; 
     406      logit("e", "could not open file (%s): %s\n", latencyfile, strerror(errno)); 
     407    } else { 
     408      retcode = -1; 
     409    } 
    363410    return retcode; 
    364411  } 
     
    366413  for (linenum = 1;; linenum++) { 
    367414    freeMsdata(msdata); // free previous data if needed 
    368     if (fgets(buffer, sizeof(buffer), infp) == NULL) { 
     415    retcode = read_latency_text(&latency_scnl_info, infp); 
     416    if (retcode) { 
     417      if (retcode < 0) { // if EOF 
     418        break; 
     419      } 
     420      logit("e", "could not parse latency on line %d\n", linenum); 
    369421      break; 
    370422    } 
    371     len = 0; 
    372     for (i = 0; i < sizeof(buffer) && buffer[i] != '\0'; i++) { 
    373       switch (buffer[i]) { 
    374       case 0: 
    375         break; 
    376       case '\r': 
    377       case '\n': 
    378         buffer[i] = '\0'; 
    379         break; 
    380       default: 
    381         len++; 
    382         break; 
    383       } 
    384     } 
    385     memset(&latency_scnl, 0, sizeof(LATENCY_SCNL)); 
    386     if (len == sizeof(LATENCY_SCNL) - 1) { 
    387       strcpy((char *)&latency_scnl, buffer); 
    388       LATENCY_SCNL_TO_STRUCT(&latency_scnl); 
    389     } else { 
    390       if (sscanf(buffer, "%s %s %s %s %s %s %s", latency_scnl.starttime, 
    391                  latency_scnl.endtime, latency_scnl.sta, latency_scnl.net, 
    392                  latency_scnl.chan, latency_scnl.loc, 
    393                  latency_scnl.latency) != 7) { 
    394         logit("e", "could not parse latency on line %d (%s)\n", linenum, 
    395               buffer); 
    396         retcode = -5; 
    397         break; 
    398       } 
    399     } 
    400  
    401     retcode = processSCNL(latency_scnl, outputfile); 
     423    if (params.Debug) 
     424    { 
     425      write_latency(&latency_scnl_info, stdout, 1); 
     426    } 
     427    retcode = processSCNL(latency_scnl_info, outputfile); 
    402428  } // end for line 
    403429  fclose(infp); 
     
    410436 * @param latencyfile the latency file 
    411437 * @param outputfile the output file 
    412  * @return 0 if sucess or ignored, non-zero if error. 
     438 * @return 0 if success, -1 if EOF, positive number if error. 
    413439 */ 
    414440static int processFile(char *latencyfile, char *outputfile) { 
     
    417443      strendswith(latencyfile, ".miniseed")) { 
    418444    retcode = processLatencyL1Z(latencyfile, outputfile); 
     445  } else if (params.Binary) { 
     446    retcode = processLatencyScnlFileBin(latencyfile, outputfile); 
    419447  } else { 
    420     retcode = processLatencyScnlFile(latencyfile, outputfile); 
     448    retcode = processLatencyScnlFileText(latencyfile, outputfile); 
    421449  } 
    422450  return retcode; 
     
    433461    return -1; 
    434462  } 
    435  
     463   
    436464  logit_init(argv[1], 0, 256, 1); 
    437465 
     
    510538      } 
    511539      if (params.Debug > 0) { 
    512         logit("o", "processFile(%s, %s)\n", latencyfile, outputfile); 
     540        logit("o", "calling processFile(%s, %s)\n", latencyfile, outputfile); 
    513541      } 
    514542      retcode = processFile(latencyfile, outputfile); 
  • trunk/src/archiving/ringplayer/makefile.unix

    r8317 r8323  
    2222          $L/dirops_ew.o \ 
    2323          $L/dirops_ew_common.o \ 
     24          $L/latency_scnl.o \ 
    2425          $L/scnl_table.o \ 
    2526          $L/sqlite3.o \ 
  • trunk/src/diagnostic_tools/latency/latency.c

    r8313 r8323  
    6565 
    6666/* versioning introduced by ISTI when incorporated into Earthworm repo */ 
    67 #define VERSION "1.1.0 - 2021-01-14" 
     67#define VERSION "1.2.0 - 2021-02-16" 
    6868 
    6969static int pid;                         // Process ID 
     
    7676static int renameChannel = 1; // Apply channel renaming conventions 
    7777static int slept = 0;         // 1 if a sleep has just occurred, 0 otherwise 
    78 static int typeLatencyScnl = 0; 
     78static int typeLatencyScnl = 0; // 0 for TYPE_TRACEBUF2, 1 for TYPE_LATENCY_SCNL, 2 for TYPE_LATENCY_SCNL_TEXT, 3 for TYPE_LATENCY_SCNL_BIN 
    7979static int ValidTraceBuf2 = 0; 
    8080 
     
    148148static TRACE2_HEADER *trh;        // Pointer to the beginning of "inmsg" 
    149149static TRACE2_HEADER *trout;      // Pointer to the beginning of "outmsg" 
    150 static LATENCY_SCNL latency_scnl; // latency scnl output 
    151 static char *latency_scnl_str = (char *)&latency_scnl; 
    152150static char orig_datatype[3]; 
    153151 
     
    593591        if (strcmp("TYPE_LATENCY_SCNL", strptr) == 0) { 
    594592          typeLatencyScnl = 1; 
     593        } 
     594        if (strcmp("TYPE_LATENCY_SCNL_TEXT", strptr) == 0) { 
     595          typeLatencyScnl = 2; 
     596        } 
     597        if (strcmp("TYPE_LATENCY_SCNL_BIN", strptr) == 0) { 
     598          typeLatencyScnl = 3; 
    595599        } 
    596600      } 
     
    933937  // Construct output message logo 
    934938  if (defaultMode != SNW_MODE) { 
    935     if (OutputType == '\0') { 
     939    if (!typeLatencyScnl) { 
    936940      outputLogo.type = Type_TraceBuf2; 
    937941    } else { 
     
    11991203 
    12001204static void writeOutputMessage(void) { 
    1201   if (OutputType == '\0') { 
     1205  if (typeLatencyScnl == 1 || typeLatencyScnl == 2) { 
     1206    int fixed; 
     1207    if (typeLatencyScnl == 1) 
     1208      fixed = 1; 
     1209    else 
     1210      fixed = 0; 
     1211    char latency_scnl_buf[LATENCY_STR_SIZE]; 
     1212    tbuf2latencystr(trout, *long_data_out, latency_scnl_buf, fixed); 
     1213    tport_putmsg(&region_out, &outputLogo, strlen(latency_scnl_buf), 
     1214                 latency_scnl_buf); 
     1215    if (debug) { 
     1216      logit("t", "Output Latency --> %s\n", latency_scnl_buf); 
     1217    } 
     1218  } else if (typeLatencyScnl == 3) { 
     1219    LATENCY_SCNL_BIN latency_scnl_bin; // latency scnl binary 
     1220    tbuf2latencybin(trout, *long_data_out, &latency_scnl_bin); 
     1221    tport_putmsg(&region_out, &outputLogo, sizeof(LATENCY_SCNL_BIN), 
     1222                 (char *)&latency_scnl_bin); 
     1223  } else { 
    12021224    if (ValidTraceBuf2) { 
    12031225      trout->endtime = trout->starttime; 
    12041226    } 
    12051227    tport_putmsg(&region_out, &outputLogo, outputLength, outmsg); 
    1206   } else { 
    1207     memset(&latency_scnl, 0, sizeof(LATENCY_SCNL)); 
    1208     sprintf(latency_scnl.starttime, "%ld", 
    1209             (long)(trout->starttime * 1000. + 0.5)); 
    1210     sprintf(latency_scnl.endtime, "%ld", (long)(trout->endtime * 1000. + 0.5)); 
    1211     strcpy(latency_scnl.sta, trout->sta); 
    1212     strcpy(latency_scnl.net, trout->net); 
    1213     strcpy(latency_scnl.chan, trout->chan); 
    1214     strcpy(latency_scnl.loc, trout->loc); 
    1215     sprintf(latency_scnl.latency, "%d", *long_data_out); 
    1216     LATENCY_SCNL_TO_STRING(&latency_scnl); 
    1217     tport_putmsg(&region_out, &outputLogo, sizeof(LATENCY_SCNL), 
    1218                  latency_scnl_str); 
    1219     if (debug) { 
    1220       logit("t", "Output Latency --> %s\n", latency_scnl_str); 
    1221     } 
    12221228  } 
    12231229} 
  • trunk/src/diagnostic_tools/latency/makefile.unix

    r8279 r8323  
    88B = $(EW_HOME)/$(EW_VERSION)/bin 
    99L = $(EW_HOME)/$(EW_VERSION)/lib 
    10 LIB_MS = $L/libmseed.a 
     10EW_LIBS = $L/latency_scnl.o \ 
     11          $L/libmseed.a 
    1112 
    1213 
     
    1617 
    1718latency: $Y 
    18         $(CC) $(CFLAGS) -o $B/latency $Y $(SPECIFIC_FLAGS) $(LIB_MS) 
     19        $(CC) $(CFLAGS) -o $B/latency $Y $(SPECIFIC_FLAGS) $(EW_LIBS) 
    1920 
    2021lint: 
  • trunk/src/grab_bag/msg_recorder/msg_recorder.c

    r8280 r8323  
    3131#include "transport.h" 
    3232 
    33 #define VERSION "1.0.307" 
     33#define VERSION "1.1.047" 
    3434 
    3535static SHM_INFO InRegion; /* shared memory region to use for i/o    */ 
     
    7070static int LogSwitch;                 /* 0 if no logfile should be written */ 
    7171static long HeartBeatInterval;        /* seconds between heartbeats        */ 
     72static char outputMode[3]; 
    7273static int Debug = 0; /* Debug flag, 0-no debug, 1-basic debug, 2-super debug */ 
    7374 
     
    273274    init[i] = 0; 
    274275 
     276  outputMode[0] = 'w'; 
     277  outputMode[1] = 't'; 
     278  outputMode[2] = '\0'; 
    275279  nLogo = 0; 
    276280 
     
    396400                  TargetDir); 
    397401          } 
     402        } 
     403      } 
     404      /*NR*/ else if (k_its("Binary")) { 
     405        if (k_int()) 
     406        { 
     407          outputMode[1] = 'b'; 
    398408        } 
    399409      } 
     
    674684  logit("", "Opening %s\n", filename); 
    675685 
    676   if ((fp = fopen(filename, "wt")) == NULL) { 
     686  if ((fp = fopen(filename, outputMode)) == NULL) { 
    677687    logit("e", "Could not open file %s\n", filename); 
    678688    ProcessorStatus = -1; 
     
    698708    MsgBuf[MsgBufLen] = '\0'; 
    699709 
    700     if (Debug) 
    701       logit("", "Recording Msg: %s", MsgBuf); 
     710    if (Debug) { 
     711      if (outputMode[1] == 'b') 
     712        logit("", "writing %ld bytes\n" , MsgBufLen); 
     713      else 
     714        logit("", "Recording Msg: %s", MsgBuf); 
     715    } 
    702716 
    703717    /* Are we still in the same day 
     
    724738      logit("", "Opening %s\n", filename); 
    725739 
    726       if ((fp = fopen(filename, "wt")) == NULL) { 
     740      if ((fp = fopen(filename, outputMode)) == NULL) { 
    727741        logit("e", "Could not open file %s\n", filename); 
    728742        ProcessorStatus = -1; 
     
    731745    } 
    732746 
    733     fprintf(fp, "%s\n", MsgBuf); 
     747    if (outputMode[1] == 'b') { 
     748      fwrite(MsgBuf, 1, MsgBufLen, fp); 
     749    } else { 
     750      fprintf(fp, "%s\n", MsgBuf); 
     751    } 
    734752    fflush(fp); 
    735753 
  • trunk/src/libsrc/util/latency_scnl.c

    r8298 r8323  
     1// for testing 
     2#include "earthworm.h" 
     3 
    14#include "latency_scnl.h" 
     5#include "time_ew.h" 
     6#include <errno.h> 
     7#include <stdio.h> 
    28#include <stdlib.h> 
    39 
    4 /** 
    5  * Convert LATENCY_SCNL to LATENCY_SCNL_BIN 
    6  * @param latency_scnl the LATENCY_SCNL 
     10// convert LATENCY_SCNL_TEXT to a single string 
     11#define LATENCY_SCNL_TEXT_TO_STRING(L)                                   \ 
     12strreplace((L)->starttime, sizeof(LATENCY_SCNL_TEXT) - 1, '\0', ' ') 
     13 
     14// convert LATENCY_SCNL_TEXT to separate strings in struct 
     15#define LATENCY_SCNL_TEXT_TO_STRUCT(L)                                   \ 
     16strreplace((L)->starttime, sizeof(LATENCY_SCNL_TEXT) - 1, ' ', '\0') 
     17 
     18/** 
     19 * Convert LATENCY_SCNL_TEXT to LATENCY_SCNL 
     20 * @param latency_scnl_text the LATENCY_SCNL_TEXT 
     21 * @param latency_scnl_info  the LATENCY_SCNL_INFO 
     22 */ 
     23void latencyscnltext2info(LATENCY_SCNL_TEXT *latency_scnl_text, 
     24                          LATENCY_SCNL_INFO *latency_scnl_info) { 
     25  memset(latency_scnl_info, 0, sizeof(LATENCY_SCNL_INFO)); 
     26  latency_scnl_info->starttime = atol(latency_scnl_text->starttime) / 1000.; 
     27  latency_scnl_info->endtime = atol(latency_scnl_text->endtime) / 1000.; 
     28  strncpy(latency_scnl_info->sta, latency_scnl_text->sta, 
     29          sizeof(latency_scnl_text->sta)); 
     30  strncpy(latency_scnl_info->net, latency_scnl_text->net, 
     31          sizeof(latency_scnl_text->net)); 
     32  strncpy(latency_scnl_info->chan, latency_scnl_text->chan, 
     33          sizeof(latency_scnl_text->chan)); 
     34  strncpy(latency_scnl_info->loc, latency_scnl_text->loc, 
     35          sizeof(latency_scnl_text->loc)); 
     36  latency_scnl_info->latency = atoi(latency_scnl_text->latency); 
     37} 
     38 
     39/** 
     40 * Convert LATENCY_SCNL_INFO to LATENCY_SCNL_BIN 
     41 * @param latency_scnl_info the LATENCY_SCNL_INFO 
    742 * @param latency_scnl_bin the LATENCY_SCNL_BIN 
    843 */ 
    9 void latencyscnl2bin(LATENCY_SCNL *latency_scnl, 
    10                      LATENCY_SCNL_BIN *latency_scnl_bin) { 
    11   latency_scnl_bin->starttime = atol(latency_scnl->starttime) / 1000.; 
    12   latency_scnl_bin->endtime = atol(latency_scnl->endtime) / 1000.; 
    13   strncpy(latency_scnl_bin->sta, latency_scnl->sta, 
     44void latencyscnlinfo2bin(LATENCY_SCNL_INFO *latency_scnl_info, 
     45                         LATENCY_SCNL_BIN *latency_scnl_bin) { 
     46  memset(latency_scnl_bin, 0, sizeof(LATENCY_SCNL_BIN)); 
     47  latency_scnl_bin->starttime = latency_scnl_info->starttime; 
     48  latency_scnl_bin->endtime = latency_scnl_info->endtime; 
     49  strncpy(latency_scnl_bin->sta, latency_scnl_info->sta, 
    1450          sizeof(latency_scnl_bin->sta)); 
    15   strncpy(latency_scnl_bin->net, latency_scnl->net, 
     51  strncpy(latency_scnl_bin->net, latency_scnl_info->net, 
    1652          sizeof(latency_scnl_bin->net)); 
    17   strncpy(latency_scnl_bin->chan, latency_scnl->chan, 
     53  strncpy(latency_scnl_bin->chan, latency_scnl_info->chan, 
    1854          sizeof(latency_scnl_bin->chan)); 
    19   strncpy(latency_scnl_bin->loc, latency_scnl->loc, 
     55  strncpy(latency_scnl_bin->loc, latency_scnl_info->loc, 
    2056          sizeof(latency_scnl_bin->loc)); 
    21   latency_scnl_bin->latency = atoi(latency_scnl->latency); 
    22 } 
     57  latency_scnl_bin->latency = latency_scnl_info->latency; 
     58} 
     59 
     60/** 
     61 * Convert LATENCY_SCNL_BIN to LATENCY_SCNL_INFO 
     62 * @param latency_scnl_bin the LATENCY_SCNL_BIN 
     63 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     64 */ 
     65void latencyscnlbin2info(LATENCY_SCNL_BIN *latency_scnl_bin, 
     66                         LATENCY_SCNL_INFO *latency_scnl_info) { 
     67  memset(latency_scnl_info, 0, sizeof(LATENCY_SCNL_INFO)); 
     68  latency_scnl_info->starttime = latency_scnl_bin->starttime; 
     69  latency_scnl_info->endtime = latency_scnl_bin->endtime; 
     70  strncpy(latency_scnl_info->sta, latency_scnl_bin->sta, 
     71          sizeof(latency_scnl_bin->sta)); 
     72  strncpy(latency_scnl_info->net, latency_scnl_bin->net, 
     73          sizeof(latency_scnl_bin->net)); 
     74  strncpy(latency_scnl_info->chan, latency_scnl_bin->chan, 
     75          sizeof(latency_scnl_bin->chan)); 
     76  strncpy(latency_scnl_info->loc, latency_scnl_bin->loc, 
     77          sizeof(latency_scnl_bin->loc)); 
     78  latency_scnl_info->latency = latency_scnl_bin->latency; 
     79} 
     80 
     81/** 
     82 * Parse the line of latency text. 
     83 * @param latency_scnl_text the LATENCY_SCNL_TEXT 
     84 * @param line the line 
     85 * @return the number of  input items successfully matched and assigned (normally 7) or -1 if EOF 
     86 */ 
     87int parselatencytext(LATENCY_SCNL_TEXT *latency_scnl_text, char *line) 
     88{ 
     89  int retVal = 7; 
     90  int len = strlen(line); 
     91  memset(latency_scnl_text, 0, sizeof(LATENCY_SCNL_TEXT)); 
     92  if (len == sizeof(LATENCY_SCNL_TEXT) - 1) { 
     93    strncpy((char *)latency_scnl_text, line, len); 
     94    LATENCY_SCNL_TEXT_TO_STRUCT(latency_scnl_text); 
     95  } else { 
     96    retVal = sscanf(line, "%s %s %s %s %s %s %s", latency_scnl_text->starttime, 
     97               latency_scnl_text->endtime, latency_scnl_text->sta, latency_scnl_text->net, 
     98               latency_scnl_text->chan, latency_scnl_text->loc, 
     99               latency_scnl_text->latency); 
     100    if (retVal == EOF) { 
     101      retVal = -1; 
     102    } 
     103  } 
     104  return retVal; 
     105} 
     106 
     107/** 
     108 * Read the latency binary packet. 
     109 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     110 * @param fp the file pointer 
     111 * @return 0 if success, -1 if EOF, positive number if error. 
     112 */ 
     113int read_latency_bin(LATENCY_SCNL_INFO *latency_scnl_info, FILE *fp) 
     114{ 
     115  LATENCY_SCNL_BIN latency_scnl_bin; 
     116  if (fread(&latency_scnl_bin, 1, sizeof(LATENCY_SCNL_BIN), fp) == sizeof(LATENCY_SCNL_BIN)) 
     117  { 
     118    latencyscnlbin2info(&latency_scnl_bin, latency_scnl_info); 
     119    return 0; 
     120  } 
     121  if (!errno) 
     122  { 
     123    errno = -1; 
     124  } 
     125  memset(latency_scnl_info, 0, sizeof(LATENCY_SCNL_INFO)); 
     126  return errno; 
     127} 
     128 
     129/** 
     130 * Read the latency text packet. 
     131 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     132 * @param fp the file pointer 
     133 * @return 0 if success, -1 if EOF, positive number if error. 
     134 */ 
     135int read_latency_text(LATENCY_SCNL_INFO *latency_scnl_info, FILE *fp) 
     136{ 
     137  int retVal; 
     138  int bufsz = sizeof(LATENCY_SCNL_TEXT) + 1; 
     139  char buffer[bufsz]; 
     140  LATENCY_SCNL_TEXT latency_scnl_text; 
     141 
     142  memset(buffer, 0, bufsz); 
     143  memset(latency_scnl_info, 0, sizeof(LATENCY_SCNL_INFO)); 
     144  if (fgets(buffer, bufsz, fp) != NULL) 
     145  { 
     146    int i, len = 0; 
     147    for (i = 0; i < bufsz && buffer[i] != '\0'; i++) { 
     148      switch (buffer[i]) { 
     149        case 0: 
     150          break; 
     151        case '\r': 
     152        case '\n': 
     153          buffer[i] = '\0'; 
     154          break; 
     155        default: 
     156          len++; 
     157          break; 
     158      } 
     159    } 
     160    retVal = parselatencytext(&latency_scnl_text, buffer); 
     161    if (retVal == 7) 
     162    { 
     163      latencyscnltext2info(&latency_scnl_text, latency_scnl_info); 
     164      return 0; 
     165    } 
     166    else if (retVal != -1) 
     167    { 
     168      logit("e", "read_latency_text could not parse a line (%d %s)\n", 
     169            retVal, buffer); 
     170    } 
     171  } 
     172  else 
     173  { 
     174    retVal = errno; 
     175    if (retVal) 
     176    { 
     177      logit("e", "read_latency_text could not read a line (%s): %s\n", 
     178            strerror(retVal)); 
     179    } 
     180    else 
     181    { 
     182      retVal = -1; 
     183    } 
     184  } 
     185  return retVal; 
     186} 
     187 
     188/** 
     189 * Convert TBUF2 to LATENCY_SCNL_BIN 
     190 * @param trh the TRACE2_HEADER 
     191 * @param latency the latency 
     192 * @param latency_scnl_bin the LATENCY_SCNL_BIN 
     193 */ 
     194void tbuf2latencybin(TRACE2_HEADER *trh, int latency, 
     195                     LATENCY_SCNL_BIN *latency_scnl_bin) 
     196{ 
     197  memset(latency_scnl_bin, 0, sizeof(LATENCY_SCNL_BIN)); 
     198  latency_scnl_bin->starttime = trh->starttime; 
     199  latency_scnl_bin->endtime = trh->endtime; 
     200  strncpy(latency_scnl_bin->sta, trh->sta, 
     201          sizeof(latency_scnl_bin->sta)); 
     202  strncpy(latency_scnl_bin->net, trh->net, 
     203          sizeof(latency_scnl_bin->net)); 
     204  strncpy(latency_scnl_bin->chan, trh->chan, 
     205          sizeof(latency_scnl_bin->chan)); 
     206  strncpy(latency_scnl_bin->loc, trh->loc, 
     207          sizeof(latency_scnl_bin->loc)); 
     208  latency_scnl_bin->latency = latency; 
     209} 
     210 
     211/** 
     212 * Convert the TBUF2 to text. 
     213 * @param trh the TRACE2_HEADER 
     214 * @param latency the latency 
     215 * @param str the string which should large enough to hold LATENCY_STR_SIZE characters 
     216 * @param fixed non-zero if fixed size 
     217 */ 
     218void tbuf2latencystr(TRACE2_HEADER *trh, int latency, char *str, int fixed) 
     219{ 
     220  memset(str, 0, sizeof(LATENCY_SCNL_TEXT)); 
     221  if (fixed) 
     222  { 
     223    // latency scnl text output 
     224    LATENCY_SCNL_TEXT* latency_scnl_text = (LATENCY_SCNL_TEXT*) str; 
     225    sprintf(latency_scnl_text->starttime, "%ld", 
     226            (long)(trh->starttime * 1000. + 0.5)); 
     227    sprintf(latency_scnl_text->endtime, "%ld", (long)(trh->endtime * 1000. + 0.5)); 
     228    strcpy(latency_scnl_text->sta, trh->sta); 
     229    strcpy(latency_scnl_text->net, trh->net); 
     230    strcpy(latency_scnl_text->chan, trh->chan); 
     231    strcpy(latency_scnl_text->loc, trh->loc); 
     232    sprintf(latency_scnl_text->latency, "%d", latency); 
     233    LATENCY_SCNL_TEXT_TO_STRING(latency_scnl_text); 
     234  } 
     235  else 
     236  { 
     237    sprintf(str, "%ld %ld %s %s %s %s %d", (long)(trh->starttime * 1000. + 0.5), 
     238            (long)(trh->endtime * 1000. + 0.5), 
     239            trh->sta, trh->net, trh->chan, trh->loc, 
     240            latency); 
     241  } 
     242} 
     243 
     244/** 
     245 * Write the latency information. 
     246 * @param latency_scnl_info the LATENCY_SCNL_INFO 
     247 * @param fp the file pointer 
     248 * @param dateFormat date format, 0 for epoch, 1 for GMT, 2 for local 
     249 */ 
     250void write_latency(LATENCY_SCNL_INFO *latency_scnl_info, FILE *fp, int dateFormat) 
     251{ 
     252  if (dateFormat == 0) // epoch 
     253  { 
     254    fprintf(fp, "%f %f %s %s %s %s %d\n", 
     255          latency_scnl_info->starttime, 
     256          latency_scnl_info->endtime, 
     257          latency_scnl_info->sta, 
     258          latency_scnl_info->net, 
     259          latency_scnl_info->chan, 
     260          latency_scnl_info->loc, 
     261          latency_scnl_info->latency); 
     262  } 
     263  else 
     264  { 
     265    char startTimeBuf[DATESTR23]; 
     266    char endTimeBuf[DATESTR23]; 
     267    switch (dateFormat) 
     268    { 
     269      case 1: // GMT 
     270      default: 
     271        datestr23(latency_scnl_info->starttime, startTimeBuf, DATESTR23); 
     272        datestr23(latency_scnl_info->endtime, endTimeBuf, DATESTR23); 
     273        break; 
     274      case 2: // local time 
     275        datestr23_local(latency_scnl_info->starttime, startTimeBuf, DATESTR23); 
     276        datestr23_local(latency_scnl_info->endtime, endTimeBuf, DATESTR23); 
     277        break; 
     278    } 
     279    fprintf(fp, "%s %s %s %s %s %s %d\n", 
     280            startTimeBuf, 
     281            endTimeBuf, 
     282            latency_scnl_info->sta, 
     283            latency_scnl_info->net, 
     284            latency_scnl_info->chan, 
     285            latency_scnl_info->loc, 
     286            latency_scnl_info->latency); 
     287  } 
     288} 
Note: See TracChangeset for help on using the changeset viewer.