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