public DcaHandler(UDPDuplex behringer, GpioController controller, DcaSetting dcaSetting) { this.dcaSetting = dcaSetting; this.behringer = behringer; this.controller = controller; var dcaPathBuilder = new StringBuilder(); dcaPathBuilder.Append("/dca/"); dcaPathBuilder.Append(dcaSetting.dca.ToString("D1")); dcaPathBuilder.Append("/fader"); dcaPath = dcaPathBuilder.ToString(); try { controller.OpenPin(dcaSetting.gpio, PinMode.InputPullUp); controller.RegisterCallbackForPinValueChangedEvent(dcaSetting.gpio, PinEventTypes.Falling, dcaDown); controller.RegisterCallbackForPinValueChangedEvent(dcaSetting.gpio, PinEventTypes.Rising, dcaUp); } catch (Exception e) { log.Info(e, $"Could not connect to pin {dcaSetting.gpio}"); throw; } }
static void Main(string[] args) { Console.WriteLine("Working..."); watcher.Created += HandlePendrive; watcher.Deleted += ClearApp; watcher.IncludeSubdirectories = true; watcher.EnableRaisingEvents = true; GpioController controller = new GpioController(); controller.OpenPin(3, PinMode.Input); controller.OpenPin(5, PinMode.Input); controller.OpenPin(7, PinMode.Input); controller.OpenPin(11, PinMode.Input); controller.RegisterCallbackForPinValueChangedEvent(3, PinEventTypes.Falling, (a, o) => { stopwatch = Stopwatch.StartNew(); }); controller.RegisterCallbackForPinValueChangedEvent(3, PinEventTypes.Rising, TurnOff); controller.RegisterCallbackForPinValueChangedEvent(5, PinEventTypes.Rising, PlayStop); controller.RegisterCallbackForPinValueChangedEvent(7, PinEventTypes.Rising, Next); controller.RegisterCallbackForPinValueChangedEvent(11, PinEventTypes.Rising, Prev); process.Exited += GetNextSong; Console.WriteLine("Subbed, starging loop..."); HandlePendrive(null, null); while (programIsWorking) { } Console.WriteLine("Exiting..."); controller.ClosePin(3); controller.ClosePin(5); controller.ClosePin(7); controller.ClosePin(11); return; }
public MuteHandler(UDPDuplex behringer, GpioController controller, MuteSetting muteSetting) { this.muteSetting = muteSetting; this.behringer = behringer; this.controller = controller; var mutePathBuilder = new StringBuilder(); mutePathBuilder.Append("/ch/"); mutePathBuilder.Append(muteSetting.channel.ToString("D2")); mutePathBuilder.Append("/mix/on"); mutePath = mutePathBuilder.ToString(); try { controller.OpenPin(muteSetting.gpio, PinMode.InputPullUp); controller.RegisterCallbackForPinValueChangedEvent(muteSetting.gpio, PinEventTypes.Falling, MuteEnabled); controller.RegisterCallbackForPinValueChangedEvent(muteSetting.gpio, PinEventTypes.Rising, MuteDisabled); } catch (Exception e) { log.Info(e, $"Could not connect to pin {muteSetting.gpio}"); throw; } }
public TalkbackHandler(UDPDuplex behringer, GpioController controller, TalkbackSetting talkbackSetting) { this.talkbackSetting = talkbackSetting; this.behringer = behringer; this.controller = controller; var talkbackPathBuilder = new StringBuilder(); talkbackPathBuilder.Append("/ch/"); talkbackPathBuilder.Append(talkbackSetting.channel.ToString("D2")); talkbackPathBuilder.Append("/mix/"); talkbackPathBuilder.Append(talkbackSetting.bus.ToString("D2")); talkbackPathBuilder.Append("/tap"); talkbackPath = talkbackPathBuilder.ToString(); try { controller.OpenPin(talkbackSetting.gpio, PinMode.InputPullUp); controller.RegisterCallbackForPinValueChangedEvent(talkbackSetting.gpio, PinEventTypes.Falling, TalkbackEnabled); controller.RegisterCallbackForPinValueChangedEvent(talkbackSetting.gpio, PinEventTypes.Rising, TalkbackDisabled); } catch (Exception e) { log.Info(e, $"Could not connect to pin {talkbackSetting.gpio}"); throw; } }
private void AssignPins() { //26 - button power out //19 - button power in //16 - page power out //20 - even pages circuit - blue //21 - odd pages circuit - yellow controller = new GpioController(); controller.OpenPin(26, PinMode.Output); controller.OpenPin(19, PinMode.Input); controller.OpenPin(16, PinMode.Output); controller.OpenPin(20, PinMode.Input); controller.OpenPin(21, PinMode.Input); controller.RegisterCallbackForPinValueChangedEvent(19, PinEventTypes.Rising, GetImage); controller.RegisterCallbackForPinValueChangedEvent(20, PinEventTypes.Rising, FlipToOdd); controller.RegisterCallbackForPinValueChangedEvent(21, PinEventTypes.Rising, FlipToEven); controller.Write(26, PinValue.High); controller.Write(16, PinValue.High); Console.WriteLine("Pins Assigned"); Thread reader = new Thread(ReadPins); reader.Start(); }
public HardwareButton(GpioController controller, int pin, ButtonTrigger myTrigger) { this.controller = controller; this.pin = pin; controller.OpenPin(pin, PinMode.InputPullDown); controller.RegisterCallbackForPinValueChangedEvent(pin, PinEventTypes.Rising, ButtonRisingHandler); controller.RegisterCallbackForPinValueChangedEvent(pin, PinEventTypes.Falling, ButtonFallingHandler); }
/// <summary> /// Creates a new instance of the HC-SCR501. /// </summary> /// <param name="outPin">OUT Pin</param> /// <param name="pinNumberingScheme">Pin Numbering Scheme</param> public Hcsr501(int outPin, PinNumberingScheme pinNumberingScheme = PinNumberingScheme.Logical) { _outPin = outPin; _controller = new GpioController(pinNumberingScheme); _controller.OpenPin(outPin, PinMode.Input); _controller.RegisterCallbackForPinValueChangedEvent(outPin, PinEventTypes.Falling, Sensor_ValueChanged); _controller.RegisterCallbackForPinValueChangedEvent(outPin, PinEventTypes.Rising, Sensor_ValueChanged); }
/// <summary> /// Creates a new instance of the HC-SCR501. /// </summary> /// <param name="outPin">OUT Pin</param> /// <param name="pinNumberingScheme">Pin Numbering Scheme</param> /// <param name="gpioController"><see cref="GpioController"/> related with operations on pins</param> /// <param name="shouldDispose">True to dispose the Gpio Controller</param> public Hcsr501(int outPin, PinNumberingScheme pinNumberingScheme = PinNumberingScheme.Logical, GpioController gpioController = null, bool shouldDispose = true) { _outPin = outPin; _shouldDispose = gpioController == null ? true : shouldDispose; _controller = gpioController ?? new GpioController(pinNumberingScheme); _controller.OpenPin(outPin, PinMode.Input); _controller.RegisterCallbackForPinValueChangedEvent(outPin, PinEventTypes.Falling, Sensor_ValueChanged); _controller.RegisterCallbackForPinValueChangedEvent(outPin, PinEventTypes.Rising, Sensor_ValueChanged); }
public Worker(ILogger <Worker> logger, GpioController controller, IHubContext <ChatHub, IChat> chatHub) { _logger = logger; _controller = controller; _chatHub = chatHub; PinEventTypes bothPinEventTypes = PinEventTypes.Falling | PinEventTypes.Rising; _controller.RegisterCallbackForPinValueChangedEvent(17, bothPinEventTypes, valueChangeHandler); _controller.RegisterCallbackForPinValueChangedEvent(27, bothPinEventTypes, valueChangeHandler); _controller.RegisterCallbackForPinValueChangedEvent(22, bothPinEventTypes, valueChangeHandler); }
public void AddCallbackRemoveAllCallbackTest() { RetryHelper.Execute(() => { int risingEventOccuredCount = 0, fallingEventOccuredCount = 0; using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { controller.OpenPin(InputPin, PinMode.Input); controller.OpenPin(OutputPin, PinMode.Output); controller.Write(OutputPin, PinValue.Low); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Falling, callback1); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Falling, callback2); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Falling, callback3); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Rising, callback4); controller.Write(OutputPin, PinValue.High); Thread.Sleep(WaitMilliSeconds); controller.UnregisterCallbackForPinValueChangedEvent(InputPin, callback1); controller.UnregisterCallbackForPinValueChangedEvent(InputPin, callback2); controller.UnregisterCallbackForPinValueChangedEvent(InputPin, callback3); controller.UnregisterCallbackForPinValueChangedEvent(InputPin, callback4); Thread.Sleep(WaitMilliSeconds); controller.Write(OutputPin, PinValue.Low); Thread.Sleep(WaitMilliSeconds); controller.Write(OutputPin, PinValue.High); Assert.Equal(1, risingEventOccuredCount); Assert.Equal(0, fallingEventOccuredCount); void callback1(object sender, PinValueChangedEventArgs e) { fallingEventOccuredCount++; } void callback2(object sender, PinValueChangedEventArgs e) { fallingEventOccuredCount++; } void callback3(object sender, PinValueChangedEventArgs e) { fallingEventOccuredCount++; } void callback4(object sender, PinValueChangedEventArgs e) { risingEventOccuredCount++; } } }); }
public void RegisterPinChanged(int pinNumber, string pinMode) { if (_changeHandlers.Contains(pinNumber)) { return; } _controller.OpenPin(pinNumber, GetPinMode(pinMode)); _controller.RegisterCallbackForPinValueChangedEvent(pinNumber, PinEventTypes.Falling, PinFalling); _controller.RegisterCallbackForPinValueChangedEvent(pinNumber, PinEventTypes.Rising, PinRising); }
public KeyPinHelper(GpioController controller, int gpio, KeyName keyName, Action <KeyStateChangedEventArgs> keyPressedCallback, Action <KeyStateChangedEventArgs> keyReleasedCallback) { _controller = controller; _gpio = gpio; _keyName = keyName; _keyReleasedCallback = keyReleasedCallback; _keyPressedCallback = keyPressedCallback; controller.OpenPin(gpio, PinMode.Input); controller.RegisterCallbackForPinValueChangedEvent(gpio, PinEventTypes.Rising, RisingHandler); controller.RegisterCallbackForPinValueChangedEvent(gpio, PinEventTypes.Falling, FallingHandler); }
/// <summary> /// Initializes a new instance of the <see cref="Switch"/> class. /// </summary> /// <param name="pin">The gpio pin.</param> public Switch( GpioController gpioController, int inPin, ulong interruptTime = 500) { this.gpioController = gpioController; this.InPin = inPin; gpioController.OpenPin(InPin); gpioController.SetPinMode(InPin, PinMode.InputPullDown); gpioController.RegisterCallbackForPinValueChangedEvent(InPin, PinEventTypes.Falling, HandleInterrupt); gpioController.RegisterCallbackForPinValueChangedEvent(InPin, PinEventTypes.Rising, HandleInterrupt); InterruptTime = interruptTime; }
public void AddCallbackFallingEdgeNotDetectedTest() { bool wasCalled = false; AutoResetEvent ev = new AutoResetEvent(false); using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { controller.OpenPin(InputPin, PinMode.Input); controller.OpenPin(OutputPin, PinMode.Output); controller.Write(OutputPin, PinValue.Low); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Falling, Callback); // Sometimes, we get an extra event just at the beginning - wait for it and then drop it ev.WaitOne(1000); wasCalled = false; controller.Write(OutputPin, PinValue.High); controller.UnregisterCallbackForPinValueChangedEvent(InputPin, Callback); Assert.False(wasCalled); } ev.Dispose(); void Callback(object sender, PinValueChangedEventArgs pinValueChangedEventArgs) { if (pinValueChangedEventArgs.PinNumber != InputPin) { return; } ev.Set(); wasCalled = true; } }
protected virtual void SetupPin() { controller.OpenPin(PedestrainLight.RedSignal.Pin, PinMode.Output); controller.OpenPin(PedestrainLight.GreenSignal.Pin, PinMode.Output); controller.OpenPin(PedestrainLight.Button.Pin, PinMode.Input); controller.RegisterCallbackForPinValueChangedEvent(PedestrainLight.Button.Pin, PinEventTypes.Rising, PinChangeEvent); }
public void HighPulledPinDoesNotChangeToLowWhenChangedToOutput() { using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { bool didTriggerToLow = false; int testPin = OutputPin; // Set value to low prior to test, so that we have a defined start situation controller.OpenPin(testPin, PinMode.Output); controller.Write(testPin, PinValue.Low); controller.ClosePin(testPin); // For this test, we use the input pin as an external pull-up controller.OpenPin(InputPin, PinMode.Output); controller.Write(InputPin, PinValue.High); Thread.Sleep(2); // If we were to use InputPullup here, this would work around the problem it seems, but it would also make our test pass under almost all situations controller.OpenPin(testPin, PinMode.Input); Thread.Sleep(50); controller.RegisterCallbackForPinValueChangedEvent(testPin, PinEventTypes.Falling, (sender, args) => { if (args.ChangeType == PinEventTypes.Falling) { didTriggerToLow = true; } }); controller.Write(testPin, PinValue.High); controller.SetPinMode(testPin, PinMode.Output); Thread.Sleep(50); Assert.False(didTriggerToLow); controller.ClosePin(OutputPin); controller.ClosePin(InputPin); } }
public HallEffectSensor() { var gpioController = new GpioController(PinNumberingScheme.Logical, new SysFsDriver()); gpioController.RegisterCallbackForPinValueChangedEvent(4, PinEventTypes.Falling | PinEventTypes.Rising, this.PinValueChanged); gpioController.WaitForEvent(3, PinEventTypes.Falling, CancellationToken.None); }
public void AddCallbackTest() { while (!Debugger.IsAttached) { Thread.Sleep(1000); } Debugger.Break(); ManualResetEvent mre = new ManualResetEvent(false); bool wasCalled = false; using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { controller.OpenPin(InputPin, PinMode.Input); controller.OpenPin(OutputPin, PinMode.Output); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Rising, callback); controller.Write(OutputPin, PinValue.High); mre.WaitOne(TimeSpan.FromSeconds(5)); Assert.True(wasCalled); } void callback(object sender, PinValueChangedEventArgs pinValueChangedEventArgs) { wasCalled = true; mre.Set(); } }
// test pressione pulsante public static void Test05() { GpioController controller = new GpioController(PinNumberingScheme.Board); var pinIN1 = 18; // PIn 18 input. Pulsante var lightTime = 1000; Console.WriteLine("Test Lettura Pulsante"); controller.OpenPin(pinIN1, PinMode.InputPullDown); controller.SetPinMode(pinIN1, PinMode.InputPullDown); //provo a impostare il pin prima di "aprirlo". Non funziona e genera runtime error controller.RegisterCallbackForPinValueChangedEvent(pinIN1, PinEventTypes.Rising, onPushButton); try { while (true) { Thread.Sleep(lightTime); //Console.WriteLine("Attendo la pressione del pulsante " + DateTime.Now.ToString()); Console.WriteLine("Pin18 in stato " + controller.Read(pinIN1).ToString()); } } finally { controller.ClosePin(pinIN1); } }
static void Main(string[] args) { controller.OpenPin(17, PinMode.Output); controller.OpenPin(18, PinMode.InputPullUp); controller.RegisterCallbackForPinValueChangedEvent(18, PinEventTypes.Rising | PinEventTypes.Falling, OnPinChange); Console.ReadKey(); }
public Rfm9XDevice(int spiBusId, int chipSelectPin, int resetPin, int interruptPin) { var settings = new SpiConnectionSettings(spiBusId, chipSelectPin) { ClockFrequency = 500000, //DataBitLength = 8, Mode = SpiMode.Mode0,// From SemTech docs pg 80 CPOL=0, CPHA=0 SharingMode = SpiSharingMode.Shared, }; rfm9XLoraModem = new SpiDevice(settings); gpioController = new GpioController(); // Factory reset pin configuration GpioPin resetGpioPin = gpioController.OpenPin(resetPin); resetGpioPin.SetPinMode(PinMode.Output); resetGpioPin.Write(PinValue.Low); Thread.Sleep(10); resetGpioPin.Write(PinValue.High); Thread.Sleep(10); // Interrupt pin for RX message & TX done notification gpioController.OpenPin(interruptPin, PinMode.InputPullDown); gpioController.RegisterCallbackForPinValueChangedEvent(interruptPin, PinEventTypes.Rising, InterruptGpioPin_ValueChanged); }
public Task StartAsync(CancellationToken cancellationToken) { _logger.LogInformation("Started"); _controller.OpenPin(PORT, PinMode.InputPullUp); _controller.RegisterCallbackForPinValueChangedEvent(PORT, PinEventTypes.Falling, Handle); return(Task.CompletedTask); }
public void CallbackOnEventWorks() { // Our mock driver maps physical pin 2 to logical pin 1 _mockedGpioDriver.Setup(x => x.OpenPinEx(1)); _mockedGpioDriver.Setup(x => x.AddCallbackForPinValueChangedEventEx(1, PinEventTypes.Rising, It.IsAny <PinChangeEventHandler>())); var ctrl = new GpioController(PinNumberingScheme.Logical, _mockedGpioDriver.Object); ctrl.OpenPin(1); // logical pin 1 on our test board bool callbackSeen = false; PinChangeEventHandler eventHandler = (sender, args) => { callbackSeen = true; Assert.Equal(1, args.PinNumber); Assert.Equal(PinEventTypes.Falling, args.ChangeType); }; ctrl.RegisterCallbackForPinValueChangedEvent(1, PinEventTypes.Rising, eventHandler); _mockedGpioDriver.Object.FireEventHandler(1, PinEventTypes.Falling); Assert.True(callbackSeen); ctrl.UnregisterCallbackForPinValueChangedEvent(1, eventHandler); }
[Trait("SkipOnTestRun", "Windows_NT")] // WindowsDriver is not very fast so this test is flaky on it. public void FastInterruptHandling() { const int numPulses = 100; // These are in ms const int pulseLength = 1; const int waitTime = 20; const double acceptableTimeFactor = 2.0; int numInterrupts = 0; int numRisingEdges = 0; using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { controller.OpenPin(InputPin, PinMode.Input); controller.OpenPin(OutputPin, PinMode.Output); controller.Write(OutputPin, PinValue.Low); while (controller.Read(InputPin) == PinValue.High) { } controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Rising, Callback); // Ensure the poll thread is ready before we continue the actual loop // If the triggers are generated by external hardware (which is what the interrupt triggering // is for), we don't know when the pulses start, so no synchronisation possible there anyway Thread.Sleep(10); Stopwatch w = Stopwatch.StartNew(); for (int i = 0; i < numPulses; i++) { controller.Write(OutputPin, PinValue.High); Thread.Sleep(TimeSpan.FromMilliseconds(pulseLength)); controller.Write(OutputPin, PinValue.Low); Thread.Sleep(TimeSpan.FromMilliseconds(waitTime)); } TimeSpan elapsed = w.Elapsed; Thread.Sleep(10); controller.UnregisterCallbackForPinValueChangedEvent(InputPin, Callback); // All pulses must be marked as rising edge Assert.Equal(numInterrupts, numRisingEdges); Assert.True(numInterrupts >= numPulses - 1, $"Expected at least {numPulses - 1}, got only {numInterrupts}"); // Allow one missing pulse // That's how long this test should last (at most). // It will usually be around 3s, but on Windows it's around 4s (for reasons unknown) double expectedMillis = numPulses * (pulseLength + waitTime); Assert.True(elapsed < TimeSpan.FromMilliseconds(expectedMillis * acceptableTimeFactor), $"Used {w.Elapsed.TotalMilliseconds}ms, expected max {expectedMillis * acceptableTimeFactor}ms"); // Write the state of the test to the log, even if it passed (for detailed analysis) _testOutputHelper.WriteLine($"Got {numInterrupts} out of {numPulses} expected. Expected a duration of {expectedMillis}, actually used {elapsed.TotalMilliseconds}ms"); } void Callback(object sender, PinValueChangedEventArgs pinValueChangedEventArgs) { numInterrupts++; // Console.WriteLine($"Seen pulse {numInterrupts}"); Assert.Equal(InputPin, pinValueChangedEventArgs.PinNumber); if (pinValueChangedEventArgs.ChangeType == PinEventTypes.Rising) { numRisingEdges++; } } }
public SwitchService(GpioController gpioController) { this.gpioController = gpioController; gpioController.OpenPin(InPinNumber); gpioController.SetPinMode(InPinNumber, PinMode.InputPullDown); gpioController.RegisterCallbackForPinValueChangedEvent(InPinNumber, PinEventTypes.Falling | PinEventTypes.Rising, OnPinChanged); }
/// <summary> /// Initialize the sensor /// </summary> public void Initialize() { _controller = new GpioController(_pinNumberingScheme); _controller.OpenPin(_pinOut, PinMode.Input); _controller.RegisterCallbackForPinValueChangedEvent(_pinOut, PinEventTypes.None, Sensor_ValueChanged); }
static void Main(string[] args) { try { var drvGpio = new LibGpiodDriver(GPIOCHIP); controller = new GpioController(PinNumberingScheme.Logical, drvGpio); //set value if (!controller.IsPinOpen(LED_PIN) && !controller.IsPinOpen(BUTTON_PIN)) { controller.OpenPin(LED_PIN, PinMode.Output); controller.OpenPin(BUTTON_PIN, PinMode.Input); } else { Console.WriteLine("LED_PIN or BUTTON_PIN is busy"); exitCode = -1; return; } controller.Write(LED_PIN, ledPinValue); //LED OFF // Console.WriteLine("CTRL+C to interrupt the read operation:"); controller.RegisterCallbackForPinValueChangedEvent(BUTTON_PIN, PinEventTypes.Rising, (o, e) => { ledPinValue = !ledPinValue; controller.Write(LED_PIN, ledPinValue); Console.WriteLine($"Press button, LED={ledPinValue}"); }); //Console ConsoleKeyInfo cki; while (true) { Console.Write("Press any key, or 'X' to quit, or "); Console.WriteLine("CTRL+C to interrupt the read operation:"); // Start a console read operation. Do not display the input. cki = Console.ReadKey(true); // Announce the name of the key that was pressed . Console.WriteLine($" Key pressed: {cki.Key}\n"); // Exit if the user pressed the 'X' key. if (cki.Key == ConsoleKey.X) { break; } } } catch (Exception ex) { Console.WriteLine($"Error: {ex}"); exitCode = -2; } finally { if (controller is not null) { controller.Dispose(); } } Environment.Exit(exitCode); }
public void AddCallbackRemoveCallbackTest() { int risingEventOccurredCount = 0, fallingEventOccurredCount = 0; using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { controller.OpenPin(InputPin, PinMode.Input); controller.OpenPin(OutputPin, PinMode.Output); controller.Write(OutputPin, PinValue.Low); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Rising, (o, e) => { risingEventOccurredCount++; }); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Rising, Callback); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Rising, (o, e) => { risingEventOccurredCount++; if (fallingEventOccurredCount == 4) { controller.UnregisterCallbackForPinValueChangedEvent(InputPin, Callback); } }); controller.RegisterCallbackForPinValueChangedEvent(InputPin, PinEventTypes.Falling, (o, e) => { fallingEventOccurredCount++; }); for (int i = 0; i < 10; i++) { controller.Write(OutputPin, PinValue.High); Thread.Sleep(WaitMilliseconds); controller.Write(OutputPin, PinValue.Low); Thread.Sleep(WaitMilliseconds); } Assert.Equal(25, risingEventOccurredCount); Assert.Equal(10, fallingEventOccurredCount); void Callback(object sender, PinValueChangedEventArgs e) { risingEventOccurredCount++; } } }
public Task StartAsync(CancellationToken cancellationToken) { if (gpio == null) { gpio = new GpioController(); } logger.LogTrace("Strating kbd watcher"); gpio.OpenPin(5); gpio.SetPinMode(5, PinMode.InputPullUp); gpio.OpenPin(6); gpio.SetPinMode(6, PinMode.InputPullUp); gpio.OpenPin(13); gpio.SetPinMode(13, PinMode.InputPullUp); gpio.OpenPin(19); gpio.SetPinMode(19, PinMode.InputPullUp); gpio.RegisterCallbackForPinValueChangedEvent(5, PinEventTypes.Rising, Pin5ChangeCallback); gpio.RegisterCallbackForPinValueChangedEvent(6, PinEventTypes.Rising, Pin6ChangeCallback); //gpio.RegisterCallbackForPinValueChangedEvent(13, PinEventTypes.Rising, PinChangeCallback); gpio.RegisterCallbackForPinValueChangedEvent(19, PinEventTypes.Rising, Pin19ChangeCallback); logger.LogTrace("kbd watcher started"); return(Task.CompletedTask); }
/// <summary> /// Получить задачу, которая завершится, когда дисплей будет готов /// </summary> /// <returns>Задача ожидания готовности дисплея</returns> public Task WaitDisplayAsync() { var tcs = new TaskCompletionSource <object>(); PinChangeEventHandler pinChange = (s, e) => { tcs.SetResult(null); }; gpioController.RegisterCallbackForPinValueChangedEvent(PIN_BUSY, PinEventTypes.Rising, pinChange); return(tcs.Task.ContinueWith(t => gpioController.UnregisterCallbackForPinValueChangedEvent(PIN_BUSY, pinChange))); }