private async Task <TimeSpan> PlayButton(bool fakeOut) { int waitMs = _r.Next(1500, 6000); WaitForEventResult pre = await _controller.WaitForEventAsync(_buttonPin, PinEventTypes.Falling, TimeSpan.FromMilliseconds(waitMs)); if (!pre.TimedOut) { return(TimeSpan.FromSeconds(-1)); } if (fakeOut) { return(await ShowFakeout()); } else { return(await ShowReal()); } }
public void WaitForEventAsyncFail() { var ctrl = new GpioController(PinNumberingScheme.Logical, _mockedGpioDriver.Object); _mockedGpioDriver.Setup(x => x.OpenPinEx(1)); _mockedGpioDriver.Setup(x => x.IsPinModeSupportedEx(1, PinMode.Input)).Returns(true); _mockedGpioDriver.Setup(x => x.WaitForEventEx(1, PinEventTypes.Rising | PinEventTypes.Falling, It.IsAny <CancellationToken>())) .Returns(new WaitForEventResult() { EventTypes = PinEventTypes.None, TimedOut = true }); Assert.NotNull(ctrl); ctrl.OpenPin(1, PinMode.Input); var task = ctrl.WaitForEventAsync(1, PinEventTypes.Falling | PinEventTypes.Rising, TimeSpan.FromSeconds(0.01)).AsTask(); task.Wait(CancellationToken.None); Assert.True(task.IsCompleted); Assert.Null(task.Exception); Assert.True(task.Result.TimedOut); Assert.Equal(PinEventTypes.None, task.Result.EventTypes); }
/// <summary>Executes the command asynchronously.</summary> /// <returns>The command's exit code.</returns> /// <remarks> /// NOTE: This test app uses the base class's <see cref="GpioCommand.CreateGpioController"/> method to create a device.<br/> /// Real-world usage would simply create an instance of <see cref="GpioController"/>: /// <code>using (var controller = new GpioController())</code> /// </remarks> public async Task <int> ExecuteAsync() { if (LedPin != null) { Console.WriteLine($"Driver={Driver}, Scheme={Scheme}, ButtonPin={ButtonPin}, LedPin={LedPin}, PressedValue={PressedValue}, OnValue={OnValue}"); } else { Console.WriteLine($"Driver={Driver}, Scheme={Scheme}, ButtonPin={ButtonPin}, PressedValue={PressedValue}, OnValue={OnValue}"); } using GpioController controller = CreateGpioController(); using CancellationTokenSource cancellationTokenSource = new(); Console.WriteLine($"Listening for button presses on GPIO {Enum.GetName(typeof(PinNumberingScheme), Scheme)} pin {ButtonPin} . . ."); // This example runs until Ctrl+C (or Ctrl+Break) is pressed, so register a local function handler. Console.CancelKeyPress += Console_CancelKeyPress; controller.OpenPin(ButtonPin); // Set the mode based on if input pull-up resistors are supported. PinMode inputMode = controller.IsPinModeSupported(ButtonPin, PinMode.InputPullUp) ? PinMode.InputPullUp : PinMode.Input; controller.SetPinMode(ButtonPin, inputMode); // Open the GPIO pin connected to the LED if one was specified. if (LedPin != null) { controller.OpenPin(LedPin.Value, PinMode.Output); controller.Write(LedPin.Value, OffValue); } PinEventTypes bothPinEventTypes = PinEventTypes.Falling | PinEventTypes.Rising; WaitForEventResult waitResult; int count = 0; do { waitResult = await controller.WaitForEventAsync(ButtonPin, bothPinEventTypes, cancellationTokenSource.Token); if (!waitResult.TimedOut) { var pressedOrReleased = waitResult.EventTypes == PressedValue ? "pressed" : "released"; Console.WriteLine($"[{count++}] Button {pressedOrReleased}: GPIO {Enum.GetName(typeof(PinNumberingScheme), Scheme)} pin number {ButtonPin}, ChangeType={waitResult.EventTypes}"); if (LedPin != null) { PinValue ledValue = waitResult.EventTypes == PressedValue ? OnValue : OffValue; controller.Write(LedPin.Value, ledValue); } } } while (!waitResult.TimedOut); controller.ClosePin(ButtonPin); if (LedPin != null) { controller.ClosePin(LedPin.Value); } Console.WriteLine("Operation cancelled. Exiting."); Console.OpenStandardOutput().Flush(); return(0); // Local function void Console_CancelKeyPress(object?sender, ConsoleCancelEventArgs e) { e.Cancel = true; cancellationTokenSource.Cancel(); Console.CancelKeyPress -= Console_CancelKeyPress; } }
public ValueTask <WaitForEventResult> WaitForEventAsync(int pinNumber, PinEventTypes eventTypes, TimeSpan timeout) { return(_controller.WaitForEventAsync(pinNumber, eventTypes, timeout)); }