Pipe In CHOP node

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 four-byte 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);
            fflush(output);
        }
        

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

        int         token;
        float       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.

(int) 1	Command Type.
(int)	Number of Channels.
(float)	Sample Data, one sample for each channel.

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.

(int) 2	Command Type.
(int)	Track Length.
(float)	Sample Rate.
(float)	Start Index.
(int)	Number of Channels.
(float)	Sample Data, one sample for each channel for each 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 four-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 four-byte tokens) and name data for each channel.

(int) 3	Command Type
(int)	Number of Names
(int)	Name Length, one per name
(char*)	Name Values, four-byte tokens

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, float *samples)
        {
            int         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);
        }
        

You can find a compilable example of a Pipe In application in:

        $HH/public/PPD.tar.Z