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]); }