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