Can I use Reactive Extensions for controlling the timing of an instrument test cycle?

Question

Here's the problem I'm trying to solve...

I'm writing a program that controls a piece of test equipment. The program polls the instrument via serial interface every second, and gets a string of test data in return.

Connection speed is 9600 baud, and the instrument only sends about 100 characters at a time, so performance is not an issue.

One of the requirements is a "cycle" mode, which is should work as follows:

1. The user sets up three timer intervals - Pre-Test time, Test time, and Inter-test time - and clicks a Start button on the UI.

2. The program commands the instrument to start a test cycle, and displays data received by the instrument until the Pre-Test time has expired.

3. The program then displays AND records the data until the Test time has expired.

4. The program then displays data until the Inter-test time has expired.

5. Steps 2 - 4 are repeated until the user clicks a Stop button on the UI.

In the past, I've written simple state machines for this kind of problem. But for this project, (and with the help of SO Rx experts), I've been able to use Rx to parse the serial data, and am very happy with the resulting code.

My intuition tells me that this problem might also be nicely handled by Rx, but it's not at all clear how to proceed.

So, is my intuition correct, or would you suggest a different approach?

If Rx is a good fit, could someone provide some quick and dirty sample code that demonstrates a solution?

Edit...as per Enigmativity:

Here's the code that reads the serial data. In a nutshell, it converts a stream of serial data into individual packet strings e.g. "A0", "C00004", "H0501100", etc. These are passed to the ProcessPacket method, which interprets the packets as instrument status, pressures, etc.

    /// <summary>
    /// Create a Reactive Extensions subscription to the selected serial port
    /// </summary>
    private IDisposable SetupSerialDataSubscription()
    {
        // Create Observable stream of chars from serial port's DataRecieved event
        var serialData = Observable
                .FromEventPattern<SerialDataReceivedEventArgs>(_serialPort, "DataReceived")

                // Collapse groups of chars into stream of individual chars
                .SelectMany(_ =>
                {
                    int bytesToRead = _serialPort.BytesToRead;
                    byte[] bytes = new byte[bytesToRead];
                    int nbrBytesRead = _serialPort.Read(bytes, 0, bytesToRead);

                    // Empty array if no bytes were actually read
                    if (nbrBytesRead == 0)
                        return new char[0];

                    var chars = Encoding.ASCII.GetChars(bytes);

                    return chars;
                })

                // Strip out null chars, which can cause trouble elsewhere (e.g. Console.WriteLine)
               .SkipWhile(c => c == '\0');

        // Emits packets, one string per packet, e.g. "A0", "C00004", "H0501100", etc
        var packets = serialData
            .Scan(string.Empty, (prev, cur) => char.IsLetter(cur) ? cur.ToString() : prev + cur)
            .Where(IsCompletePacket);

        // Process each packet, on the UI thread
        var packetsSubscription = packets
            .ObserveOn(this)
            .Subscribe(packet => ProcessPacket(packet) );

        return packetsSubscription;
    }

Answer 1

You could do this. Use a helper method to emit an infinite IEnumerable which delivers a recording signal (true/false) and a timespan:

public IEnumerable<Tuple<TimeSpan, bool>> GetTestPeriods()
{
    TimeSpan preTestTime = TimeSpan.FromSeconds(5);
    TimeSpan testTime = TimeSpan.FromSeconds(3);
    TimeSpan interTestTime = TimeSpan.FromSeconds(2);

    yield return Tuple.Create(preTestTime, false);
    while(true)
    {
        yield return Tuple.Create(testTime, true);
        yield return Tuple.Create(interTestTime, false);
    }
}

This can be used to create a cycle stream that outputs a recording signal at the appropriate times:

// cycle outputs true at start of recording period
// false at start of a display period
var cycle = GetTestPeriods()
    .Select(s => Observable.Return(s.Item2)
        .Concat(Observable.Empty<bool>().Delay(s.Item1)))
    .Concat();

Now we can make some random data:

// make some random data
var random = new Random();
var dummyData = Observable.Interval(TimeSpan.FromSeconds(1))
                          .Select(_ => random.Next(10));

Set up a subject to signal stopping (you could use FromEventPattern to hook a button click here instead):

var stop = new Subject<Unit>();

And then combine the data with the record signal until stop is signaled. This pairs each data point with a boolean indicating if it is to be displayed or recorded:

var output = cycle.CombineLatest(dummyData, (c,d) => Tuple.Create(c,d))
    .TakeUntil(stop);

This stream you could publish and subscribe a couple of streams using Where filters to get the data to record separately from the data to display. Here's a test that timestamps the stream and dumps the data out:

// timestamp data and "record" or "display" it.
output.Timestamp()
    .Subscribe(x => {
        if(x.Value.Item1)
            Console.WriteLine(x.Timestamp + ": Recording " + x.Value.Item2);
        else
            Console.WriteLine(x.Timestamp + ": Displaying " + x.Value.Item2);
    },
    () => Console.WriteLine("Stopped")); 

Finally some code that emits the stop signal:

Console.ReadLine();
stop.OnNext(Unit.Default);