int HandleCommEvent() { // Get and clear current errors on the port. DWORD dwErrors; COMSTAT comStat; DWORD ret; if (!ClearCommError(hCommPort, &dwErrors, &comStat)) { LOG(ERR,"Arduino::HandleCommEvent - error calling ClearCommError: %d",ret=GetLastError()); return ret; } if (dwErrors & CE_FRAME) { LOG(ERR,"Arduino::HandleCommEvent - hardware detected a framing error!"); } if (dwErrors & CE_OVERRUN) { LOG(ERR,"Arduino::HandleCommEvent - A character-buffer overrun has occurred. The next character is lost!"); } if (dwErrors & CE_RXOVER) { LOG(ERR,"Arduino::HandleCommEvent - An input buffer overflow has occurred!"); } if (dwErrors & CE_RXPARITY) { LOG(ERR,"Arduino::HandleCommEvent - hardware detected a parity error!"); } if (comStat.cbInQue>0) { LOG(HELPERFUNC,"Arduino::HandleCommEvent - %d bytes in receiving buffer!",comStat.cbInQue); return BlockingRead(comStat.cbInQue); } return 0; }
// // Copies received data from the receive stream into the user-specified buffer. // Returns number of bytes copied to the buffer. // static LONG ContextDispatch( PPR_SOCKET Ps, // PR-socket handle PHANDLE_CONTEXT Ctx, // PR-context PCHAR pBuffer,// pointer to a buffer to copy data LONG Size // size of the buffer in bytes ) { LONG bSize, bRead = 0; HRESULT hResult; if (bSize = StreamAvaliable(Ctx->pStream)) { if ((Ctx->Status & STREAM_FULL_REPLACE) && (bSize < Size)) // Loading all data from the socket while((bRead = BlockingRead(Ps, Ctx->cBuffer, MAX_CONTENT_BUFFER_SIZE, 0)) > 0); // Read 'amount' of bytes from the stream and return'em to the caller hResult = CoInvoke(Ctx->pStream, Read, pBuffer, Size, (PULONG)&bRead); ASSERT(hResult == S_OK); ASSERT(bRead > 0); // If the end of the stream reached - clear it. if (bSize == bRead) StreamClear(Ctx->pStream); } // if (bSize = StreamGetLength(Ctx->pStream)) return(bRead); }
//********************************************************* // main //********************************************************* int main(int argc, char *argv[]) { int index = 0; int i_framefield; int i_streamfield; int i_arrayfield; char filedirname[1024]; int fieldsize = 0; int *fieldfp; int *streamfp; int *arraystatfp; char fielddata[2000][8]; int n_wrote; int i_samp; int i_frame; int i_array, j_array; unsigned short us_in; short s_in; unsigned char uc_in; signed char c_in; int i_in; unsigned u_in; long long ll_in[MAX_STREAM_FIELDS][MAX_SAMPLES_PER_FRAME]; int first_time = 1; char name[128]; int len; int i0; struct fifoStruct fs; /* find if we are fox, rush, or msnbc from the file name */ /* first strip out the directory */ len = strlen(argv[0]); for (i0=len-1; i0>0 && (argv[0][i0-1] != '/'); i0--); for (i_in = i0; i_in<len; i_in++) { name[i_in-i0] = argv[0][i_in]; } name[i_in-i0] = '\0'; if (strncmp(name, "fox", 3)==0) { strcpy(LNKFILE, FOX_LNKFILE); PORT = RNC_PORT; EXT = FOX_EXT; } else if (strncmp(name, "msn", 3)==0) { strcpy(LNKFILE, MSNBC_LNKFILE); PORT = DNC_PORT; EXT = MSNBC_EXT; } else if (strncmp(name, "rus", 3)==0) { strcpy(LNKFILE, RUSH_LNKFILE); PORT = TEA_PORT; EXT = RUSH_EXT; } else { fprintf(stderr, "unknown program: %s\n", name); exit(0); } fs.i_in = fs.i_out = 0; if (argc!=2) Usage(name); if (argv[1][0]=='-') Usage(name); sprintf(filedirname, "%s/%lu.%c", RAWDIR, time(NULL),EXT); if (mkdir(filedirname, 0777)<0) { fprintf(stderr, "could not create dirfile %s\n", filedirname); exit(0); } unlink(LNKFILE); if (symlink(filedirname, LNKFILE)<0) { fprintf(stderr, "could not create link from `%s' to `%s'", filedirname, LNKFILE); exit(0); } strncpy(hostname, argv[1], 250); tty_fd = party_connect(hostname, PORT); MakeFrameList(); //** read and parse the data */ while (1) { // for each superframe index = 0; // start of superframe // Look for sync word while (index == 0) { n_bytemon+=BlockingRead(sizeof(unsigned), &fs, tty_fd, hostname, PORT); peek(&fs, (char *)&u_in, sizeof(unsigned)); if (u_in==SYNCWORD) { printf("\rRead %d bytes for frame %d ", n_bytemon, n_sync); advance(&fs, sizeof(unsigned)); index = 1; is_lost = 0; n_bytemon = 0; n_sync++; fflush(stdout); } else { is_lost = 1; advance(&fs, 1); printf("\rlost for %3d bytes (frame %d) ", n_bytemon, n_sync); fflush(stdout); } } // read frameset char n_bytemon+=BlockingRead(sizeof(char), &fs, tty_fd, hostname, PORT); pop(&fs, &channelset_oth, 1); printf("channelset %d \n", (int)channelset_oth); // Read once per frame fields for (i_framefield = 0; i_framefield < n_framefields; i_framefield++) { switch (framefields[i_framefield]->type) { case 'u': case 's': fieldsize = 2; break; case 'U': case 'S': fieldsize = 4; break; default: break; } n_bytemon+=BlockingRead(fieldsize, &fs, tty_fd, hostname, PORT); pop(&fs, fielddata[i_framefield], fieldsize); index++; } #ifdef __SPIDER__ // Read Array Statistics // Array Stats per Superframe n_bytemon+=BlockingRead(2, &fs, tty_fd, hostname, PORT); pop(&fs, (char *)(&us_in), 2); n_array_in_sframe = us_in; if (n_array_in_sframe > NUM_ARRAY_STAT) { fprintf(stderr, "error: Unreasonably large number of array stats (%d). Something is wrong.\n", n_array_in_sframe); continue; } // starting index n_bytemon+=BlockingRead(2, &fs, tty_fd, hostname, PORT); pop(&fs, (char *)(&us_in), 2); i_array = us_in; if (i_array > NUM_ARRAY_STAT) { fprintf(stderr, "error: invalid array stats index. Something is wrong.\n"); continue; } // read them... for (j_array = 0; j_array<n_array_in_sframe; j_array++) { pop(&fs, (char *)(&uc_in), 1); array_statistics[i_array] = uc_in; i_array++; if (i_array>= NUM_ARRAY_STAT) i_array=0; } #endif n_bytemon+=BlockingRead(2, &fs, tty_fd, hostname, PORT); pop(&fs, (char *)(&us_in), 2); if (first_time) { MakeStreamList(); // reset first_time later } if (n_streamfields == 0) { n_streamfields = us_in; if (n_streamfields>n_streamfieldlist) { fprintf(stderr, "error file asks for more streamfields than are listed (%u > %u)\n", n_streamfields, n_streamfieldlist); n_streamfields = 0; } else { printf("\nstream contains %u out of %u stream fields\n", n_streamfields, n_streamfieldlist); } } // check for bad n_streamfields if ((n_streamfields != us_in) || (n_streamfields==0)) { printf("\nChange in number of stream fields (%d vs %u), or bad data...\n" "\nIf this persists, you might want to restart\n", n_streamfields, us_in); continue; } if (first_time) { MakeStreamList(); MakeFormatFile(filedirname); OpenDirfilePointers(&fieldfp, &streamfp, &arraystatfp, filedirname); first_time = 0; } // Read stream gains and offsets for (i_streamfield = 0; i_streamfield < n_streamfields; i_streamfield++) { n_bytemon+=BlockingRead(sizeof(unsigned short), &fs, tty_fd, hostname, PORT); pop(&fs, (char *)&us_in, sizeof(unsigned short)); stream_gains[i_streamfield] = us_in; if (stream_gains[i_streamfield] == 0) { printf("\nzero gain for field %s. Setting to 1\n", streamfields[i_streamfield]->field); stream_gains[i_streamfield]=1; } switch (streamfields[i_streamfield]->type) { case 'u': n_bytemon+=BlockingRead(sizeof(short), &fs, tty_fd, hostname, PORT); pop(&fs, (char *)&us_in, sizeof(short)); stream_offsets[i_streamfield] = us_in; break; case 's': // 16 bit offsets n_bytemon+=BlockingRead(sizeof(short), &fs, tty_fd, hostname, PORT); pop(&fs, (char *)&s_in, sizeof(short)); stream_offsets[i_streamfield] = s_in; break; case 'U': n_bytemon+=BlockingRead(sizeof(int), &fs, tty_fd, hostname, PORT); pop(&fs, (char *)&u_in, sizeof(int)); stream_offsets[i_streamfield] = u_in; break; case 'S': // 32 bit offsets n_bytemon+=BlockingRead(sizeof(int), &fs, tty_fd, hostname, PORT); pop(&fs, (char *)&i_in, sizeof(int)); stream_offsets[i_streamfield] = i_in; break; } } // Handle the 1 Hz frame stuff. for (i_frame = 0; i_frame < STREAMFRAME_PER_SUPERFRAME; i_frame++) { // Read the >= 1 Hz streamed data. for (i_streamfield = 0; i_streamfield < n_streamfields; i_streamfield++) { n_bytemon+=BlockingRead(streamList[channelset_oth][i_streamfield].samples_per_frame*streamList[channelset_oth][i_streamfield].bits/8, &fs, tty_fd, hostname, PORT); for (i_samp = 0; i_samp<streamList[channelset_oth][i_streamfield].samples_per_frame; i_samp++) { // read streamfield; if (streamList[channelset_oth][i_streamfield].bits == 4) { // FIXME: deal with 4 bit fields. There should always be a pair of them } else if (streamList[channelset_oth][i_streamfield].bits == 8) { pop(&fs, (char *)&c_in, 1); ll_in[i_streamfield][i_samp] = (int)c_in * stream_gains[i_streamfield]+stream_offsets[i_streamfield]; if (streamList[channelset_oth][i_streamfield].doDifferentiate) { // undiferentiate... ll_in[i_streamfield][i_samp] = stream_offsets[i_streamfield]; stream_offsets[i_streamfield]+=(int)c_in * stream_gains[i_streamfield]; } } else if (streamList[channelset_oth][i_streamfield].bits == 16) { pop(&fs, (char *)&s_in, 2); ll_in[i_streamfield][i_samp] = (int)s_in * stream_gains[i_streamfield]+stream_offsets[i_streamfield]; if (streamList[channelset_oth][i_streamfield].doDifferentiate) { // undiferentiate... ll_in[i_streamfield][i_samp] = stream_offsets[i_streamfield]; stream_offsets[i_streamfield]+=(int)s_in * stream_gains[i_streamfield]; } } else { fprintf(stderr,"Unsupported stream resolution... (a definite bug!)\n"); } } } // read frame sync byte n_bytemon+=BlockingRead(sizeof(char), &fs, tty_fd, hostname, PORT); pop(&fs, (char *)(&uc_in), sizeof(char)); if (uc_in != 0xa5) { printf("bad sync byte: must be lost %x\n", (int)uc_in); i_frame = STREAMFRAME_PER_SUPERFRAME; break; } else { // write the slow data at 1 hz, even though it is only updated slower than that // this is so we can get near-realtime updated data. for (i_framefield=0; i_framefield<n_framefields; i_framefield++) { switch (framefields[i_framefield]->type) { case 'u': case 's': fieldsize = 2; break; case 'U': case 'S': fieldsize = 4; break; default: break; } n_wrote = write(fieldfp[i_framefield], fielddata[i_framefield], fieldsize); if (n_wrote != fieldsize) { fprintf(stderr, "\nWriting field data unsuccesful. Out of disk space?\n"); } } #ifdef __SPIDER__ for (i_arrayfield = 0; i_arrayfield < n_array_in_sframe; i_arrayfield++) { n_wrote = write(arraystatfp[i_arrayfield], array_statistics+i_arrayfield, 1); if (n_wrote != 1) { fprintf(stderr, "\nWriting field data unsuccesful. %s %d %d\n", strerror(errno), arraystatfp[i_arrayfield], i_arrayfield); } } #endif for (i_streamfield = 0; i_streamfield < n_streamfields; i_streamfield++) { for (i_samp = 0; i_samp<streamList[channelset_oth][i_streamfield].samples_per_frame; i_samp++) { switch (streamfields[i_streamfield]->type) { case 'u': us_in = ll_in[i_streamfield][i_samp]; n_wrote = write(streamfp[i_streamfield], (char *)(&us_in), 2); if (n_wrote != 2) { fprintf(stderr, "Writing field data unsuccesful. Out of disk space?\n"); } break; case 's': s_in = ll_in[i_streamfield][i_samp]; n_wrote = write(streamfp[i_streamfield], (char *)(&s_in), 2); if (n_wrote != 2) { fprintf(stderr, "Writing field data unsuccesful. Out of disk space?\n"); } break; case 'U': u_in = ll_in[i_streamfield][i_samp]; n_wrote = write(streamfp[i_streamfield], (char *)(&u_in), 4); if (n_wrote != 4) { fprintf(stderr, "Writing field data unsuccesful. Out of disk space?\n"); } break; case 'S': i_in = ll_in[i_streamfield][i_samp]; n_wrote = write(streamfp[i_streamfield], (char *)(&i_in), 4); if (n_wrote != 4) { fprintf(stderr, "Writing field data unsuccesful. Out of disk space?\n"); } break; } } // next samp } // next streamfield } // endif } // next frame } // end while 1 return (0); // can't ever get here }
int main(int argc, char *argv[]) { char dirfilename[1024]; int i_ch; char fieldlist[255][255]; DIRFILE *df_out; int fp_lnc; int n_read = 0; struct fifoStruct fs; int i_frame = 0; uint8_t c_in; int16_t s_in; uint16_t u_in; int32_t S_in; uint32_t U_in; double x_in; time_t t; fs.i_in = fs.i_out = 0; if (argc!=2) Usage(); if (argv[1][0]=='-') Usage(); strncpy(hostname, argv[1], 250); sprintf(dirfilename, "%s/%lu.l", RAWDIR, time(NULL)); df_out = gd_open(dirfilename, GD_RDWR | GD_UNENCODED | GD_CREAT | GD_TRUNC); /* add fields to dirfile */ for (i_ch =0; slowDLList[i_ch].name[0] != '\0'; i_ch++) { convertToUpper(slowDLList[i_ch].name, fieldlist[i_ch]); if (slowDLList[i_ch].encode == SDL_SCALE) { gd_add_raw(df_out, fieldlist[i_ch], GD_FLOAT64, 1, 0); } else { switch (slowDLList[i_ch].type) { case 'c': gd_add_raw(df_out, fieldlist[i_ch], GD_UINT8, 1, 0); break; case 's': gd_add_raw(df_out, fieldlist[i_ch], GD_INT16, 1, 0); break; case 'u': gd_add_raw(df_out, fieldlist[i_ch], GD_UINT16, 1, 0); break; case 'S': gd_add_raw(df_out, fieldlist[i_ch], GD_INT32, 1, 0); break; case 'U': gd_add_raw(df_out, fieldlist[i_ch], GD_UINT32, 1, 0); break; default: break; // shouldn't be possible } } } gd_flush(df_out, NULL); unlink(LNKFILE); if (symlink(dirfilename, LNKFILE)<0) { fprintf(stderr, "could not create link from `%s' to `%s'", dirfilename, LNKFILE); exit(0); } strncpy(hostname, argv[1], 250); fp_lnc = party_connect(hostname, PORT); while (1) { do { if (nFifo(&fs)<4) { n_read += BlockingRead(4, &fs, fp_lnc, hostname, PORT); } peek(&fs, (char *)&U_in, 4); advance(&fs, 1); } while (U_in != SLOWDLSYNCWORD); advance(&fs, 4-1); for (i_ch =0; slowDLList[i_ch].name[0] != '\0'; i_ch++) { // read the word switch (slowDLList[i_ch].type) { case 'c': if (nFifo(&fs)<1) { n_read += BlockingRead(1, &fs, fp_lnc, hostname, PORT); } pop(&fs, (char *)&c_in, 1); break; case 's': if (nFifo(&fs)<2) { n_read += BlockingRead(2, &fs, fp_lnc, hostname, PORT); } pop(&fs, (char *)&s_in, 2); break; case 'u': if (nFifo(&fs)<2) { n_read += BlockingRead(2, &fs, fp_lnc, hostname, PORT); } pop(&fs, (char *)&u_in, 2); break; case 'S': if (nFifo(&fs)<4) { n_read += BlockingRead(4, &fs, fp_lnc, hostname, PORT); } pop(&fs, (char *)&S_in, 4); break; case 'U': if (nFifo(&fs)<4) { n_read += BlockingRead(4, &fs, fp_lnc, hostname, PORT); } pop(&fs, (char *)&U_in, 4); break; default: break; } // write the word if (slowDLList[i_ch].encode == SDL_SCALE) { switch (slowDLList[i_ch].type) { case 'c': x_in = (double)c_in / (double)0xff; break; case 'u': x_in = (double)u_in / (double)0xffff; break; case 'U': x_in = (double)U_in / (double)0xffff; break; default: // not allowed break; } x_in = slowDLList[i_ch].min + x_in * (slowDLList[i_ch].max - slowDLList[i_ch].min); gd_putdata(df_out, fieldlist[i_ch], i_frame, 0, 1, 0, GD_FLOAT64, &x_in); } else { switch (slowDLList[i_ch].type) { case 'c': gd_putdata(df_out, fieldlist[i_ch], i_frame, 0, 1, 0, GD_UINT8, &c_in); break; case 's': gd_putdata(df_out, fieldlist[i_ch], i_frame, 0, 1, 0, GD_INT16, &s_in); break; case 'u': gd_putdata(df_out, fieldlist[i_ch], i_frame, 0, 1, 0, GD_UINT16, &u_in); break; case 'S': gd_putdata(df_out, fieldlist[i_ch], i_frame, 0, 1, 0, GD_INT32, &S_in); break; case 'U': gd_putdata(df_out, fieldlist[i_ch], i_frame, 0, 1, 0, GD_UINT32, &U_in); break; default: // shouldn't happen break; } } } // next i_ch; t = time(NULL); printf("%s: frame %4d - %s", argv[0], i_frame, ctime(&t)); i_frame++; } return 0; }