Add support for driving SERDES GPO

[jonnew]

The FMC Link Controller device exposes the GPOSTATE register that allows the user to toggle the SERDES GPO pins for a fast feedback signal to various headstages and miniscopes. The effect of this register depends on the headstage, miniscope, or whatever that is attached to the port. This means that creating a generic sink to toggle these pins may not be the best approach. Instead, when the device is configured in the context of a MultiDeviceFactory , its behavior should be shaped to line up with the pins that available in that context. In fact, we are at a nice starting point since GPO configuration will likely be integrated into ConfigurePortController which is specialized for different MultiDeviceFactory contexts. We will then need to pass GPO configuration state to whatever sink node we build that references the device address of the corresponding MultiDeviceFactory-specialized ConfigurePortController.

[jonnew]

After some thinking, doing this correctly might take some finesse. The effect of these GPOs depends on the headstage that is communicating over the port. Although they can be manipulated through hardware, it might not be such a good idea to expose this functionality so directly. I created a class that can do this:

using System;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using Bonsai;

namespace OpenEphys.Onix1
{

    /// <summary>
    /// Specifies the state of a port controller's GPIO pins.
    /// </summary>
    /// <remarks>
    /// Pin 0 is inaccessible because it is used for issuing hardware resets.
    /// </remarks>
    [Flags]
    public enum PortControllerGpioState : byte
    {
        /// <summary>
        /// Specifies that pin 1 is high.
        /// </summary>
        Pin1 = 0x1,
        /// <summary>
        /// Specifies that pin 2 is high.
        /// </summary>
        Pin2 = 0x2,
        /// <summary>
        /// Specifies that pin 3 is high.
        /// </summary>
        Pin3 = 0x4,
    }

    /// <summary>
    /// Controls a port controller's general purpose output pins (GPOs).
    /// </summary>
    /// <remarks>
    /// This data IO operator must be linked to an appropriate configuration, such as a <see
    /// cref="ConfigureHeadstage64.PortControl"/>, using a shared <c>DeviceName</c>. The effect of a GPO
    /// depends on the hardware attached to the port.
    /// </remarks>
    [Description("Controls a headstage-64 onboard optical stimulus sequencer.")]
    public class PortControllerGpo : Sink<PortControllerGpioState>
    {
        /// <inheritdoc cref = "SingleDeviceFactory.DeviceName"/>
        [TypeConverter(typeof(PortController.NameConverter))]
        [Description(SingleDeviceFactory.DeviceNameDescription)]
        [Category(DeviceFactory.ConfigurationCategory)]
        public string DeviceName { get; set; }

        /// <summary>
        /// Gets or sets a value indicating if GPO trigger mode is active.
        /// </summary>
        /// <remarks>
        /// If true, then the GPOs will be cleared immediately after they are set in order to issue brief
        /// triggers. If set to false, then GPOs will maintain their state between updates.
        /// </remarks>
        public bool TriggerMode { get; set; }

        /// <summary>
        /// Updates the port controller's GPOs.
        /// </summary>
        /// <param name="source"> A sequence of <see cref="PortControllerGpioState"/> values indicating the
        /// state of the port controller's 3 user-accessible digital output pins</param>
        /// <returns> A sequence that is identical to <paramref name="source"/>.</returns>
        public override IObservable<PortControllerGpioState> Process(IObservable<PortControllerGpioState> source)
        {
            return DeviceManager.GetDevice(DeviceName).SelectMany(deviceInfo =>
            {
                var device = deviceInfo.GetDeviceContext(typeof(PortController));
                var triggerMode = TriggerMode;
                return source.Do(value => {
                    device.WriteRegister(PortController.GPOSTATE, (byte)value);
                    if (triggerMode)
                    {
                        device.WriteRegister(PortController.GPOSTATE, 0);
                    }
                });
            });
        }
    }
}

But, i think it might be too generic and too powerful to expose directly. What we actually want, at least currently, is a less general version of this operator. We want to to make the Headstage64ElectricalStimulatorTrigger and Headstage64OpticalStimulatorTrigger operators more general. They can either except a sequence of doubles, in which case the register version of trigger with an optional delay will be used, or a sequence of bools in which they will actually use a specialized version the PortControllerGpo above. This is tricky because these two operations use different ONI devices.