In order to read information with this chop, a separate application has to be developed to write to a FIFO in the proper format. The following sections describe and give sample code (written in C) for opening a file and writing values that will be accepted by the Pipe In CHOP.

To create a file that the Pipe In CHOP will read from, use the following code to open a new FIFO called FIFO_NAME. Define FIFO_NAME to be the desired file name to create. The output stream that is used for writing will block until a reader is connected to the file.

#include    <sys/types.h>
#include    <sys/stat.h>
#include    <stdio.h>
mode_t       prev_mask;
FILE        *output = 0;
/* Create a new fifo */
prev_mask = umask(0);
mkfifo (FIFO_NAME, 0666);
umask(prev_mask);
/* Open the file for writing */
fprintf(stderr,
"Awaiting reader of FIFO %s\n\r", FIFO_NAME);
output = fopen(FIFO_NAME, "wb");

The Pipe In chop reads information from the FIFO in eight-byte big endian chunks of data called tokens, so it is necessary to write to the file in the same format. There is also a method in place for sending an escape character in case a reset is required in the middle of parsing a command.

The reset character is an integer value of 170. When this byte is received, followed by a byte with a value of zero, the current parsing is reset. In order to send a value of 170 without the command being reset, two bytes with a 170 value must be sent consecutively so that the Pipe In CHOP will disregard the first value.

#define ESCAPE_CHARACTER        170
void
write_byte(char b, FILE *output)
{
    /* Prepend escape character */
    if (b == ESCAPE_CHARACTER)
      fputc(ESCAPE_CHARACTER, output); 
      fputc(b, output);
}
void
write_values(const char *p, int size, FILE *output)
{
    int          i;
    for(i=0; i<size; i++)
      write_byte(p[i], output);
}
void
send_reset(FILE *output)
{
    fputc(ESCAPE_CHARACTER, output);
    fputc(0, output);
    fputc(ESCAPE_CHARACTER, output);
    fputc(0, output);
    fputc(ESCAPE_CHARACTER, output);
    fputc(0, output);
    fputc(ESCAPE_CHARACTER, output);
    fputc(0, output);
    fflush(output);
}

Using these functions, any 8 bytes of data (e.g. 00000001, 3.141, Chan, …) can be sent to the file. To send a reset signal, four escape sequences are written to pad to 8 bytes. It is a good idea to send a reset signal before the command and flush the FIFO at the end of a command.

int64       token;
double            sample;
send_reset(output); 
/* Send a command here */
write_values((char *)&token, sizeof(token), output);
write_values((char *)&sample, sizeof(sample), output);
fflush(output);

The first type of command that the Pipe In CHOP will read is used to get the most recent channel data. It has a default sample rate of 30 samples per second, CHOP length of 1, and a start position of 0. This command allows the number of channels to be set and the samples associated with those channels to be read.

The second type of command that can be parsed is used to upload a full set of samples to create a waveform. The sample rate, track length, start position, number of channels, and samples for each channel to fill the track length must be provided. The channel samples must be interleaved so that all the channels for one index are filled before moving forward to the next index.

This command allows the channels to be assigned names before they are created. Since the names are usually strings, it is important to remember to write them as eight-byte tokens (padded with zeroes at the end if necessary) so they will be parsed correctly. This format requires the number of names to be set, followed by the name length (in number of eight-byte tokens) and name data for each channel.

For each name, the following data is read:

This command causes the Pipe In CHOP to disconnect the network connection. It is typically sent by the Pipe Out CHOP when its Active parameter is turned off or if the node is bypassed.

Using command type 1 as an example, the following function could be used to send a command to the FIFO which will be read by the Pipe In CHOP.

void
send_current_values(FILE *output, int num, double *samples)
{
    int64       token;
    int         j;
    send_reset(output);             /* just to be safe */
    /* Command Type */
    token = 1;
    write_values((char *)&token, sizeof(token), output);
    /* Number of Channels */
    token = num;
    write_values((char *)&token, sizeof(token), output);
    /* Sample Values */
    for(j=0; j<num; j++)
      write_values((char *)&samples[j],
        sizeof(samples[j]), output);
      fflush(output);
}