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; }
/// <summary> /// Test and see if a pin set to output on high resets after a few seconds or remains set. /// </summary> /// <param name="args"></param> static void Main(string[] args) { Console.WriteLine("Hello World!"); const int RST_PIN = 15; const int RANDO = 31; using (var gpio = new GpioController(PinNumberingScheme.Board)) { gpio.OpenPin(RST_PIN, PinMode.Output); gpio.Write(RST_PIN, PinValue.High); gpio.OpenPin(RANDO, PinMode.Input); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); while (stopwatch.Elapsed.TotalSeconds < 30) { if (gpio.Read(RANDO) == PinValue.Low) { Console.WriteLine("Pin does not stay high!"); } } //NOTE: Test indicates that the pin stays set to high. gpio.ClosePin(RST_PIN); gpio.ClosePin(RANDO); stopwatch.Stop(); } }
public void WriteSpan() { _mockedGpioDriver.Setup(x => x.OpenPinEx(1)); _mockedGpioDriver.Setup(x => x.OpenPinEx(2)); _mockedGpioDriver.Setup(x => x.IsPinModeSupportedEx(1, PinMode.Output)).Returns(true); _mockedGpioDriver.Setup(x => x.IsPinModeSupportedEx(2, PinMode.Output)).Returns(true); _mockedGpioDriver.Setup(x => x.GetPinModeEx(1)).Returns(PinMode.Output); _mockedGpioDriver.Setup(x => x.GetPinModeEx(2)).Returns(PinMode.Output); _mockedGpioDriver.Setup(x => x.WriteEx(1, PinValue.High)); _mockedGpioDriver.Setup(x => x.WriteEx(2, PinValue.Low)); _mockedGpioDriver.Setup(x => x.ClosePinEx(1)); _mockedGpioDriver.Setup(x => x.ClosePinEx(2)); var ctrl = new GpioController(PinNumberingScheme.Logical, _mockedGpioDriver.Object); Assert.NotNull(ctrl); ctrl.OpenPin(1, PinMode.Output); ctrl.OpenPin(2, PinMode.Output); Assert.True(ctrl.IsPinOpen(1)); Span <PinValuePair> towrite = stackalloc PinValuePair[2]; towrite[0] = new PinValuePair(1, PinValue.High); towrite[1] = new PinValuePair(2, PinValue.Low); ctrl.Write(towrite); ctrl.ClosePin(1); ctrl.ClosePin(2); Assert.False(ctrl.IsPinOpen(1)); }
public void SetPinModeSetsDefaultValue() { using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver())) { 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); controller.OpenPin(testPin, PinMode.Input); Thread.Sleep(50); // It's not possible to change the direction while listening to events (causes an error). Therefore the real behavior of the driver // can only be tested with a scope (or if we had a third pin connected in the lab hardware) // We do another test here and make sure the // pin is really high now controller.Write(testPin, PinValue.High); controller.SetPinMode(testPin, PinMode.Output); controller.SetPinMode(InputPin, PinMode.Input); Assert.True(controller.Read(InputPin) == PinValue.High); controller.ClosePin(OutputPin); controller.ClosePin(InputPin); } }
public void Stop() { lock (_locker) { Pause(); if (_controller.IsPinOpen(_in1)) { _controller.ClosePin(_in1); } if (_controller.IsPinOpen(_in2)) { _controller.ClosePin(_in2); } if (_controller.IsPinOpen(_in3)) { _controller.ClosePin(_in3); } if (_controller.IsPinOpen(_in4)) { _controller.ClosePin(_in4); } _pwma.DutyCycle = Math.Abs(0); _pwmb.DutyCycle = Math.Abs(0); Dispose(true); } }
static void Main(string[] args) { using (var gpioController = new GpioController(PinNumberingScheme.Board)) { var ledPin = 11; var buttonPin = 12; gpioController.OpenPin(ledPin, PinMode.Output); gpioController.OpenPin(buttonPin, PinMode.InputPullUp); var exitAt = DateTime.UtcNow.AddSeconds(20); try { while (DateTime.UtcNow < exitAt) { if (gpioController.Read(buttonPin) == PinValue.Low) { gpioController.Write(ledPin, PinValue.High); } else { gpioController.Write(ledPin, PinValue.Low); } } } finally { gpioController.Write(ledPin, PinValue.Low); gpioController.ClosePin(ledPin); gpioController.ClosePin(buttonPin); System.Console.WriteLine("Closed pins"); } } }
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 void Off() { if (_gpio.IsPinOpen(_powerPin)) { _gpio.ClosePin(_powerPin); } }
static void Main(string[] args) { Console.WriteLine("Initializing GPIO"); using (var gpio = new GpioController()) using (var cts = new CancellationTokenSource()) { Console.CancelKeyPress += (s, e) => cts.Cancel(); gpio.OpenPin(PIR_PIN, PinMode.Input); gpio.OpenPin(LED_PIN, PinMode.Output); Console.WriteLine("Monitoring PIR sensor. ctrl+c to cancel."); bool lastOn = false; while (!cts.IsCancellationRequested) { bool pirOn = gpio.Read(PIR_PIN) == true; if (lastOn != pirOn) { Console.WriteLine($"Motion sensor is now {(pirOn ? "on" : "off")}"); lastOn = pirOn; gpio.Write(LED_PIN, pirOn); } } Console.WriteLine("Cleaning up"); gpio.ClosePin(PIR_PIN); gpio.ClosePin(LED_PIN); } }
internal void Exit() { Console.WriteLine("Closing pins."); gpioController.ClosePin(upPinNum); gpioController.ClosePin(downPinNum); gpioController.Dispose(); }
public void Off() { if (IsOn) { Debug.WriteLine($"{_relayDescription} OFF."); _gpio.ClosePin(_pin); } }
public void OpenTwiceThrows() { var ctrl = new GpioController(PinNumberingScheme.Logical, _mockedGpioDriver.Object); _mockedGpioDriver.Setup(x => x.OpenPinEx(1)); _mockedGpioDriver.Setup(x => x.ClosePinEx(1)); ctrl.OpenPin(1); Assert.Throws <InvalidOperationException>(() => ctrl.OpenPin(1)); ctrl.ClosePin(1); Assert.Throws <InvalidOperationException>(() => ctrl.ClosePin(1)); }
public void CleanUp() { childSocket.Close(); controller.ClosePin(26); controller.ClosePin(19); controller.ClosePin(16); controller.ClosePin(20); controller.ClosePin(21); controller.Dispose(); running = false; }
public Task StopAsync(CancellationToken cancellationToken) { logger.LogTrace("Stopping kbd watcher"); gpio.ClosePin(5); gpio.ClosePin(6); gpio.ClosePin(13); gpio.ClosePin(19); gpio.Dispose(); gpio = null; logger.LogTrace("Stopped kbd watcher"); return(Task.CompletedTask); }
public void Cleanup() { foreach (int pinNo in OutputPins) { _gpioController.ClosePin(pinNo); } foreach (int pinNo in InputPins) { _gpioController.ClosePin(pinNo); } _gpioController = null; }
public virtual void Dispose() { gpio.Write(rsPinNumber, PinValue.Low); gpio.ClosePin(rsPinNumber); gpio.Write(ePinNumber, PinValue.Low); gpio.ClosePin(ePinNumber); foreach (int pinNumber in dataPins) { gpio.Write(pinNumber, PinValue.Low); gpio.ClosePin(pinNumber); } }
public void Start() { using (GpioController gpio = new GpioController(PinNumberingScheme.Logical, new RaspberryPi3Driver())) for (int x = 0; x < 50; x++) { { gpio.OpenPin(TRIG, PinMode.Output); gpio.Write(TRIG, 0); gpio.OpenPin(ECHO, PinMode.Input); Thread.Sleep(TimeSpan.FromSeconds(0.1)); var startScanning = DateTime.Now.AddSeconds(2); gpio.Write(TRIG, 1); Thread.Sleep(TimeSpan.FromSeconds(0.1)); Boolean worked = true; gpio.Write(TRIG, 0); while (gpio.Read(ECHO) == 0) { if (DateTime.Now > startScanning) { Console.WriteLine("Failed aftre 2 sec"); gpio.ClosePin(ECHO); gpio.ClosePin(TRIG); worked = false; break; } } if (worked) { var start = DateTime.Now; while (gpio.Read(ECHO) == 1) { } var stop = DateTime.Now; //Console.WriteLine(stop.Ticks); distance = ((stop.Ticks - start.Ticks) * 17) / 10000; Console.WriteLine(distance); gpio.ClosePin(ECHO); gpio.ClosePin(TRIG); } } } }
private static void Main(string[] args) { if (HandleArguments(args)) { Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { e.Cancel = true; KeepRunning = false; }; if (!Directory.Exists(PhotoDirectory)) { Directory.CreateDirectory(PhotoDirectory); } gpioController.OpenPin(GreenLedPin, PinMode.Output); gpioController.OpenPin(PirPin, PinMode.Input); var currentMotionDetectedIteration = 0; while (KeepRunning) { var motionStatus = gpioController.Read(PirPin); if (motionStatus == PinValue.Low) { Console.WriteLine("All clear here..."); gpioController.Write(GreenLedPin, PinValue.Low); currentMotionDetectedIteration = 0; } else { Console.WriteLine("Motion detected! Taking a photo..."); gpioController.Write(GreenLedPin, PinValue.High); currentMotionDetectedIteration++; // Делаем фото на каждое пятое срабатывание датчика if (IterationForPhoto % currentMotionDetectedIteration == 0) { TakePhoto(); } } Thread.Sleep(DelayInMilliseconds); } gpioController.Write(GreenLedPin, PinValue.Low); gpioController.ClosePin(GreenLedPin); gpioController.ClosePin(PirPin); Console.WriteLine($"{Environment.NewLine}Exited"); } }
public void Stop() { lock (_locker) { IsRunning = false; if (_controller.IsPinOpen(_trigger)) { _controller.ClosePin(_trigger); } if (_controller.IsPinOpen(_echo)) { _controller.ClosePin(_echo); } } }
static void Main(string[] args) { Init().Wait(); // Wait until the app unloads or is cancelled var cts = new CancellationTokenSource(); AssemblyLoadContext.Default.Unloading += (ctx) => cts.Cancel(); Console.CancelKeyPress += (sender, cpe) => cts.Cancel(); WhenCancelled(cts.Token).Wait(); gpioController.ClosePin(GPIO_MOTAR_STBY); gpioController.ClosePin(GPIO_MOTAR_AIN1); gpioController.ClosePin(GPIO_MOTAR_AIN2); rollRequestWorker.CancelAsync(); }
public void Stop() { lock (_locker) { IsRunning = false; if (_controller.IsPinOpen(_left)) { _controller.ClosePin(_left); } if (_controller.IsPinOpen(_right)) { _controller.ClosePin(_right); } } }
public void Close(WebServerEventArgs e) { try { var rawUrl = e.Context.Request.RawUrl.TrimStart('/'); var args = rawUrl.Split('/'); if (args.Length < 2) { WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.BadRequest); return; } var pinNumber = Convert.ToInt32(args[1]); if (_controller.IsPinOpen(pinNumber)) { _controller.ClosePin(pinNumber); } WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.OK); } catch (Exception) { WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.BadRequest); } }
private static void PwmRaspiTest(RaspberryPiBoard raspi) { int pinNumber = 12; // PWM0 pin Console.WriteLine("Blinking and dimming an LED - Press any key to quit"); while (!Console.KeyAvailable) { GpioController ctrl = raspi.CreateGpioController(); ctrl.OpenPin(pinNumber); ctrl.SetPinMode(pinNumber, PinMode.Output); ctrl.Write(pinNumber, PinValue.Low); Thread.Sleep(500); ctrl.Write(pinNumber, PinValue.High); Thread.Sleep(1000); ctrl.ClosePin(pinNumber); ctrl.Dispose(); var pwm = raspi.CreatePwmChannel(0, 0, 9000, 0.1); pwm.Start(); for (int i = 0; i < 10; i++) { pwm.DutyCycle = i * 0.1; Thread.Sleep(500); } pwm.Stop(); pwm.Dispose(); } Console.ReadKey(true); }
static void Main() { const int ledPin = 20; // Set up our controller using (GpioController controller = new GpioController()) { // Set our pin to export controller.OpenPin(ledPin); // Set our pin to output controller.SetPinMode(ledPin, PinMode.Output); for (int i = 0; i < 3; i++) { // Turn our pin on controller.Write(ledPin, PinValue.High); Thread.Sleep(1000); // Turn our pin off controller.Write(ledPin, PinValue.Low); Thread.Sleep(1000); } // Close our pin controller.ClosePin(ledPin); } }
static void Main(string[] args) { Console.WriteLine("Hello HackSoc!"); GpioController controller = new GpioController(PinNumberingScheme.Board); var pin = 10; var buttonPin = 26; controller.OpenPin(pin, PinMode.Output); controller.OpenPin(buttonPin, PinMode.InputPullUp); try { while (true) { if (controller.Read(buttonPin) == false) { controller.Write(pin, PinValue.High); } else { controller.Write(pin, PinValue.Low); } } } finally { controller.ClosePin(pin); } }
public string GetGpio() { //System.Device.Gpio.GPIOController t= new System.Device.Gpio.GPIOController(); var c = new GpioController(PinNumberingScheme.Logical); // Board var pin = 23; var timeOut = 500; c.OpenPin(pin, PinMode.Output); // while(true) // { c.Write(pin, PinValue.High); Thread.Sleep(timeOut); c.Write(pin, PinValue.Low); Thread.Sleep(timeOut); c.Write(pin, PinValue.High); Thread.Sleep(timeOut); c.Write(pin, PinValue.Low); Thread.Sleep(timeOut); // } c.ClosePin(pin); return("Pin" + pin.ToString() + " Is at " + "unknown"); }
protected override void CloseChannel(int pinNumber, int pwmChannel) { ValidatePWMChannel(pinNumber); _controller.ClosePin(_servoPin); _servoPin = -1; _isRunning = false; }
static void Main(string[] args) { GpioController controller = new GpioController(PinNumberingScheme.Board); Console.WriteLine("Hello World!"); var pin = 10; var lightTime = 300; controller.OpenPin(pin, PinMode.Output); try { while (true) { controller.Write(pin, PinValue.High); Thread.Sleep(lightTime); controller.Write(pin, PinValue.Low); Thread.Sleep(lightTime); } } finally { controller.ClosePin(pin); } }
public void ClosePin(int pinNumber) { if (_controller.IsPinOpen(pinNumber)) { _controller.ClosePin(pinNumber); } }
/// <summary> /// Pulses the light a number of times corresponding to the character's alphabet index /// </summary> /// <param name="reply"></param> private static void PulseReply(HelloReply reply) { using (GpioController controller = GetController()) { var onTime = 100; var offTime = 50; var pin = 40; controller.OpenPin(pin, PinMode.Output); try { foreach (char c in reply.Message) { var pulseCount = Math.Max(c.ToString().ToUpper()[0] - 64, 0); Console.Write(c); for (int i = 0; i < pulseCount; i++) { controller.Write(pin, PinValue.High); Console.Write("."); Thread.Sleep(onTime); controller.Write(pin, PinValue.Low); Thread.Sleep(offTime); } Thread.Sleep(500); Console.WriteLine(); } } finally { controller.ClosePin(pin); } } }