protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
base.AddCallbackForPinValueChangedEvent(pinNumber, eventTypes, callback);
// Yield our time slice, so the event handler has time to start.
// Otherwise, we may miss the first event.
Thread.Sleep(0);
}
protected internal abstract void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventType, PinChangeEventHandler callback);
/// <inheritdoc/> protected override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback) => throw new NotImplementedException();
/// <summary> /// Removes a handler for a pin value changed event. /// </summary> /// <param name="pinNumber">The pin number in the driver's logical numbering scheme.</param> /// <param name="callback">Delegate that defines the structure for callbacks when a pin value changed event occurs.</param> protected internal override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback) => LookupOpenPin(pinNumber).RemoveCallbackForPinValueChangedEvent(callback);
/// <inheritdoc/>
protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
if ((eventTypes & PinEventTypes.Rising) != 0 || (eventTypes & PinEventTypes.Falling) != 0)
{
LibGpiodDriverEventHandler eventHandler = _pinNumberToEventHandler.GetOrAdd(pinNumber, PopulateEventHandler);
if ((eventTypes & PinEventTypes.Rising) != 0)
{
eventHandler.ValueRising += callback;
}
if ((eventTypes & PinEventTypes.Falling) != 0)
{
eventHandler.ValueFalling += callback;
}
}
else
{
throw ExceptionHelper.GetArgumentException(ExceptionResource.InvalidEventType);
}
}
protected override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
RemoveCallbackForPinValueChangedEventEx(pinNumber, callback);
_event = null !;
}
protected override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
_event = callback;
AddCallbackForPinValueChangedEventEx(pinNumber, eventTypes, callback);
}
/// <summary>
/// Adds a handler for a pin value changed event.
/// </summary>
/// <param name="pinNumber">The pin number in the driver's logical numbering scheme.</param>
/// <param name="eventTypes">The event types to wait for.</param>
/// <param name="callback">Delegate that defines the structure for callbacks when a pin value changed event occurs.</param>
protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
ValidatePinNumber(pinNumber);
InitializeSysFS();
_sysFSDriver.OpenPin(pinNumber);
_sysFSDriver.SetPinMode(pinNumber, GetModeForUnixDriver(_sysFSModes[pinNumber]));
_sysFSDriver.AddCallbackForPinValueChangedEvent(pinNumber, eventTypes, callback);
}
/// <inheritdoc/> protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback) => _internalDriver.AddCallbackForPinValueChangedEvent(pinNumber, eventTypes, callback);
protected internal override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
throw new PlatformNotSupportedException();
}
/// <summary>
/// Adds a callback that will be invoked when pinNumber has an event of type eventType.
/// </summary>
/// <param name="pinNumber">The pin number in the controller's numbering scheme.</param>
/// <param name="eventTypes">The event types to wait for.</param>
/// <param name="callback">The callback method that will be invoked.</param>
public void RegisterCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
int logicalPinNumber = GetLogicalPinNumber(pinNumber);
if (!_openPins.Contains(logicalPinNumber))
{
throw new InvalidOperationException("Can not add callback for a pin that is not open.");
}
_driver.AddCallbackForPinValueChangedEvent(logicalPinNumber, eventTypes, callback);
}
protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventType, PinChangeEventHandler callback)
{
throw new NotImplementedException();
}
/// <summary>
/// Removes a handler for a pin value changed event.
/// </summary>
/// <param name="pinNumber">The pin number in the driver's logical numbering scheme.</param>
/// <param name="callback">Delegate that defines the structure for callbacks when a pin value changed event occurs.</param>
protected internal override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
if (!_devicePins.ContainsKey(pinNumber))
{
throw new InvalidOperationException("Attempted to remove a callback for a pin that is not listening for events.");
}
_devicePins[pinNumber].ValueFalling -= callback;
_devicePins[pinNumber].ValueRising -= callback;
if (_devicePins[pinNumber].IsCallbackListEmpty())
{
_pinsToDetectEventsCount--;
bool closePollFileDescriptor = (_pinsToDetectEventsCount == 0);
RemovePinFromPoll(pinNumber, ref _devicePins[pinNumber].FileDescriptor, ref _pollFileDescriptor, true, closePollFileDescriptor, true);
_devicePins[pinNumber].Dispose();
_devicePins.Remove(pinNumber);
}
}
/// <summary>
/// Adds a handler for a pin value changed event.
/// </summary>
/// <param name="pinNumber">The pin number in the driver's logical numbering scheme.</param>
/// <param name="eventTypes">The event types to wait for.</param>
/// <param name="callback">Delegate that defines the structure for callbacks when a pin value changed event occurs.</param>
protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventType, PinChangeEventHandler callback)
{
if (!_devicePins.ContainsKey(pinNumber))
{
_devicePins.Add(pinNumber, new UnixDriverDevicePin());
_pinsToDetectEventsCount++;
AddPinToPoll(pinNumber, ref _devicePins[pinNumber].FileDescriptor, ref _pollFileDescriptor, out _);
}
if (eventType.HasFlag(PinEventTypes.Rising))
{
_devicePins[pinNumber].ValueRising += callback;
}
if (eventType.HasFlag(PinEventTypes.Falling))
{
_devicePins[pinNumber].ValueFalling += callback;
}
SetPinEventsToDetect(pinNumber, (GetPinEventsToDetect(pinNumber) | eventType));
InitializeEventDetectionThread();
}
public void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
}
/// <inheritdoc/> protected internal override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback) => _internalDriver.RemoveCallbackForPinValueChangedEvent(pinNumber, callback);
public abstract void RemoveCallbackForPinValueChangedEventEx(int pinNumber, PinChangeEventHandler callback);
public void UnregisterCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
throw new NotImplementedException();
}
public abstract void AddCallbackForPinValueChangedEventEx(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback);
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
_controller = new GpioController(PinNumberingScheme.Logical);
var buttonPin = 17;
_controller.OpenPin(_redPin, PinMode.Output);
_controller.OpenPin(_greenPin, PinMode.Output);
PinChangeEventHandler buttonPushedDown = (object sender, PinValueChangedEventArgs args) => { ButtonPushedDown(args); };
PinChangeEventHandler buttonLetGo = (object sender, PinValueChangedEventArgs args) => { ButtonLetGo(args); };
var startTime = DateTime.Now;
_controller.OpenPin(buttonPin, PinMode.InputPullUp);
_controller.RegisterCallbackForPinValueChangedEvent(buttonPin, PinEventTypes.Falling, buttonPushedDown);
_controller.RegisterCallbackForPinValueChangedEvent(buttonPin, PinEventTypes.Rising, buttonLetGo);
while (true)
{
Task.Delay(new TimeSpan(0, 0, 0, 0, 500)).Wait();
// Possible double tap
if (!_buttonPressed && _elaspedTimes.Count > 1)
{
if (_elaspedTimes.All(x => x <= 1000))
{
// Alternate Lights
Console.WriteLine("Double tap");
_controller.Write(_redPin, PinValue.Low);
_controller.Write(_greenPin, PinValue.High);
Thread.Sleep(200);
_controller.Write(_redPin, PinValue.High);
_controller.Write(_greenPin, PinValue.Low);
Thread.Sleep(200);
_controller.Write(_redPin, PinValue.Low);
_controller.Write(_greenPin, PinValue.High);
Thread.Sleep(200);
_controller.Write(_redPin, PinValue.High);
_controller.Write(_greenPin, PinValue.Low);
Thread.Sleep(200);
ResetVariables();
}
}
else if (!_buttonPressed && _elaspedTimes.Count == 1)
{
if (_elaspedTimes[0] > 1500)
{
_controller.Write(_redPin, PinValue.High);
_controller.Write(_greenPin, PinValue.Low);
Console.WriteLine("Red LED On");
}
else
{
_controller.Write(_redPin, PinValue.Low);
_controller.Write(_greenPin, PinValue.High);
Console.WriteLine("Green LED On");
}
ResetVariables();
}
else
{
Console.WriteLine("Lights Off");
_controller.Write(_redPin, PinValue.Low);
_controller.Write(_greenPin, PinValue.Low);
}
}
//Task.Delay(new TimeSpan(0, 0, 0, 0, sampleMilliseconds)).Wait(); //wait
//int count = 0;
//try
//{
// while (true)
// {
// Console.WriteLine($"Button Value at {count} - " + controller.Read(buttonPin));
// count++;
// if (controller.Read(buttonPin) == false)
// {
// controller.Write(redPin, PinValue.High);
// Console.WriteLine("Red LED On");
// }
// else
// {
// controller.Write(redPin, PinValue.Low);
// Console.WriteLine("Red LED Off");
// }
// Thread.Sleep(2000);
// Console.WriteLine("Sleeping");
// }
//}
//finally
//{
// controller.ClosePin(redPin);
// Console.WriteLine("Closing Pin");
// Console.WriteLine("Program finsihed");
//}
}
protected override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
lock (_callbackContainersLock)
{
if (_callbackContainers.TryGetValue(pinNumber, out var cb))
{
cb.EventTypes = cb.EventTypes | eventTypes;
cb.OnPinChanged += callback;
}
else
{
var cb2 = new CallbackContainer(pinNumber, eventTypes);
cb2.OnPinChanged += callback;
_callbackContainers.Add(pinNumber, cb2);
}
}
}
public void UnregisterCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
_controller.UnregisterCallbackForPinValueChangedEvent(pinNumber, callback);
}
/// <summary> /// Adds a handler for a pin value changed event. /// </summary> /// <param name="pinNumber">The pin number in the driver's logical numbering scheme.</param> /// <param name="eventTypes">The event types to wait for.</param> /// <param name="callback">Delegate that defines the structure for callbacks when a pin value changed event occurs.</param> protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback) => LookupOpenPin(pinNumber).AddCallbackForPinValueChangedEvent(eventTypes, callback);
/// <summary>
/// Adds a handler for a pin value changed event.
/// </summary>
/// <param name="pinNumber">The pin number in the driver's logical numbering scheme.</param>
/// <param name="eventTypes">The event types to wait for.</param>
/// <param name="callback">Delegate that defines the structure for callbacks when a pin value changed event occurs.</param>
protected internal override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
ValidatePinNumber(pinNumber);
_interruptDriver.OpenPin(pinNumber);
_pinModes[pinNumber].InUseByInterruptDriver = true;
_interruptDriver.AddCallbackForPinValueChangedEvent(pinNumber, eventTypes, callback);
}
public void RegisterCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventType, PinChangeEventHandler callback)
{
_real.RegisterCallbackForPinValueChangedEvent(pinNumber, eventType, callback);
}
/// <inheritdoc/>
protected override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
_pinModes[pinNumber].InUseByInterruptDriver = true;
base.OpenPin(pinNumber);
base.AddCallbackForPinValueChangedEvent(pinNumber, eventTypes, callback);
}
protected internal abstract void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback);
public void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
}
protected internal override void RemoveCallbackForPinValueChangedEvent(int pinNumber, PinChangeEventHandler callback)
{
if (_pinNumberToEventHandler.TryGetValue(pinNumber, out LibGpiodDriverEventHandler eventHandler))
{
eventHandler.ValueFalling -= callback;
eventHandler.ValueRising -= callback;
if (eventHandler.IsCallbackListEmpty())
{
_pinNumberToEventHandler.TryRemove(pinNumber, out eventHandler);
eventHandler.Dispose();
}
}
else
{
throw ExceptionHelper.GetInvalidOperationException(ExceptionResource.NotListeningForEventError);
}
}
/// <inheritdoc/>
protected override void AddCallbackForPinValueChangedEvent(int pinNumber, PinEventTypes eventTypes, PinChangeEventHandler callback)
{
if (eventTypes == PinEventTypes.None)
{
throw new ArgumentException($"{PinEventTypes.None} is an invalid value.", nameof(eventTypes));
}
if (eventTypes.HasFlag(PinEventTypes.Falling))
{
_gpioTriggers[pinNumber] |= GpioTrigger.Falling;
_pinFallingHandlers[pinNumber] += callback;
}
if (eventTypes.HasFlag(PinEventTypes.Rising))
{
_gpioTriggers[pinNumber] |= GpioTrigger.Rising;
_pinRisingHandlers[pinNumber] += callback;
}
FtFunction.FT4222_GPIO_SetInputTrigger(_ftHandle, (GpioPort)pinNumber, _gpioTriggers[pinNumber]);
}
