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