public void ClosePin(int pinNumber)
{
if (_controller.IsPinOpen(pinNumber))
{
_controller.ClosePin(pinNumber);
}
}
public void On()
{
if (!_gpio.IsPinOpen(_powerPin))
{
_gpio.OpenPin(_powerPin, PinMode.Output);
}
}
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));
}
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 ActionResult SetPinOn(int pinNumber)
{
if (!gpioController.IsPinOpen(pinNumber))
{
gpioController.OpenPin(pinNumber, PinMode.Output);
}
gpioController.Write(pinNumber, PinValue.High);
return(NoContent());
}
public void SwitchOn()
{
if (!_controller.IsPinOpen(_pin))
{
_controller.OpenPin(_pin, PinMode.Output);
_logger?.LogDebug("GPIO pin opened: {pin}", _pin);
}
_controller.Write(_pin, PinValue.High);
_logger?.LogDebug("PIN on: {pin}", _pin);
}
public void IsPinOpenTest()
{
using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver()))
{
Assert.False(controller.IsPinOpen(LedPin));
controller.OpenPin(LedPin);
Assert.True(controller.IsPinOpen(LedPin));
controller.ClosePin(LedPin);
Assert.False(controller.IsPinOpen(LedPin));
}
}
public void LedOn()
{
lock (_locker)
{
if (!_controller.IsPinOpen(_ledPin))
{
_controller.OpenPin(_ledPin, PinMode.Output);
}
_controller.Write(_ledPin, PinValue.High);
}
}
public void IsPinOpenOnInputTest()
{
using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver()))
{
// Open pin in input mode (default)
Assert.False(controller.IsPinOpen(LedPin));
controller.OpenPin(LedPin, PinMode.Input);
Assert.True(controller.IsPinOpen(LedPin));
controller.ClosePin(LedPin);
Assert.False(controller.IsPinOpen(LedPin));
}
}
public void OpenPin(int pin, PinValue onValue)
{
if (!_gpio.IsPinOpen(pin))
{
// There is a flash of low potential on an output between setting pin as output
// and writing output to high. Sequence below charges internal capatitance before
// setting pin as output. This minimalise initial low level on output before it is set high.
// This might be important when active state = PinValue low.
// To eliminate this completely, passive hardware integrator circuit should help.
_gpio.OpenPin(pin, PinMode.InputPullUp);
Task.Delay(10).Wait();
_gpio.SetPinMode(pin, PinMode.Output);
_gpio.Write(pin, !onValue);
}
}
public static PinState ReadState(int pin)
{
PinState state = new PinState
{
Pin = pin,
StateOn = false
};
try
{
GpioController controller = new GpioController();
if (!controller.IsPinOpen(pin))
{
controller.OpenPin(pin, PinMode.Input);
}
var mode = controller.GetPinMode(pin);
if (!PinMode.Input.Equals(mode))
{
controller.SetPinMode(pin, PinMode.Input);
}
var x = controller.Read(pin);
if (x.Equals(PinValue.High))
{
state.StateOn = true;
}
}
catch (Exception ex)
{
//TODO: log Error
}
return(state);
}
public ActionResult <string> Post([FromBody] string toggle)
{
try
{
GpioController controller = new GpioController();
if (!controller.IsPinOpen(pin))
{
controller.OpenPin(pin, PinMode.Output);
}
if ("on".Equals(toggle))
{
controller.Write(pin, PinValue.High);
return(Ok("Toggled on"));
}
else
{
controller.Write(pin, PinValue.Low);
return(Ok("Toggled off"));
}
}
catch (Exception ex)
{
return(UnprocessableEntity(ex));
}
}
public void Start()
{
lock (_locker)
{
IsRunning = true;
if (!_controller.IsPinOpen(_left))
{
_controller.OpenPin(_left, PinMode.Input);
}
if (!_controller.IsPinOpen(_right))
{
_controller.OpenPin(_right, PinMode.Input);
}
Task.Run(() => PerformContinuousReads());
}
}
/// <inheritdoc />
public DeviceStatus CurrentStatus()
{
if (_controller == null)
{
return(DeviceStatus.Disconnected("GPIO controller not connected"));
}
if (!_controller.IsPinOpen(_pin))
{
return(DeviceStatus.Disconnected($"Pin {_pin} not open"));
}
var value = _controller.Read(_pin);
if (value != PinValue.High && value != PinValue.Low)
{
return(DeviceStatus.Error($"Unkown value {value} on pin"));
}
else if (value == _readPinValue)
{
return(DeviceStatus.Closed($"{value} value on pin"));
}
else
{
return(DeviceStatus.Open($"{value} value on pin"));
}
}
public static string Toggle(PinState state)
{
try
{
GpioController controller = new GpioController();
if (!controller.IsPinOpen(state.Pin))
{
controller.OpenPin(state.Pin, PinMode.Output);
}
if (state.StateOn)
{
controller.Write(state.Pin, PinValue.High);
return($"Toggled pin {state.Pin} on");
}
else
{
controller.Write(state.Pin, PinValue.Low);
return($"Toggled pin {state.Pin} off");
}
}
catch (Exception ex)
{
return(ex.ToString());
}
}
public void GpioControllerCreateOpenClosePin()
{
_mockedGpioDriver.Setup(x => x.OpenPinEx(1));
_mockedGpioDriver.Setup(x => x.IsPinModeSupportedEx(1, PinMode.Output)).Returns(true);
_mockedGpioDriver.Setup(x => x.GetPinModeEx(1)).Returns(PinMode.Output);
_mockedGpioDriver.Setup(x => x.WriteEx(1, PinValue.High));
_mockedGpioDriver.Setup(x => x.ClosePinEx(1));
var ctrl = new GpioController(PinNumberingScheme.Logical, _mockedGpioDriver.Object);
Assert.NotNull(ctrl);
ctrl.OpenPin(1, PinMode.Output);
Assert.True(ctrl.IsPinOpen(1));
ctrl.Write(1, PinValue.High);
ctrl.ClosePin(1);
Assert.False(ctrl.IsPinOpen(1));
}
public void Write(int pin, bool value)
{
if (!_controller.IsPinOpen(pin))
{
_controller.OpenPin(pin, PinMode.Output);
}
_controller.Write(pin, value ? PinValue.High : PinValue.Low);
}
public void Start()
{
lock (_locker)
{
IsRunning = true;
if (!_controller.IsPinOpen(_echo))
{
_controller.OpenPin(_echo, PinMode.Input);
}
if (!_controller.IsPinOpen(_trigger))
{
_controller.OpenPin(_trigger, PinMode.Output);
_controller.Write(_trigger, PinValue.Low);
}
Task.Run(() => PerformContinuousReads());
}
}
/// <inheritdoc />
public void Connect(IRpiConnectionFactory factory)
{
_controller = factory.CreateGpio();
if (!_controller.IsPinOpen(_pin))
{
_controller.OpenPin(_pin, PinMode.InputPullDown);
}
}
public void IsPinOpenOnOutputTest()
{
// Separate test to check the IsPinOpen works also when the PinMode is Output, See Bug #776
using (GpioController controller = new GpioController(GetTestNumberingScheme(), GetTestDriver()))
{
Assert.False(controller.IsPinOpen(LedPin));
controller.OpenPin(LedPin, PinMode.Output);
Assert.True(controller.IsPinOpen(LedPin));
controller.Write(LedPin, PinValue.High);
Assert.True(controller.IsPinOpen(LedPin));
controller.Write(LedPin, PinValue.Low);
Assert.True(controller.IsPinOpen(LedPin));
controller.ClosePin(LedPin);
Assert.False(controller.IsPinOpen(LedPin));
}
}
public Task SetPinAsync(int pinNumber, PinValue value)
{
if (!gpioController.IsPinOpen(pinNumber))
{
gpioController.OpenPin(pinNumber, PinMode.Output);
}
gpioController.Write(pinNumber, value);
return(Task.CompletedTask);
}
void EnsureOpenPin(Led led, PinMode pinMode)
{
if (!GpioController.IsPinOpen(led.Pin) || GpioController.GetPinMode(led.Pin) != pinMode)
{
if (GpioController.IsPinOpen(led.Pin))
{
GpioController.ClosePin(led.Pin);
}
GpioController.OpenPin(led.Pin, pinMode);
}
}
/// <summary>
/// Ensures pin is open and is set to output mode
/// </summary>
private void PreparePin(int pinNumber)
{
if (!_gpioController.IsPinOpen(pinNumber))
{
_gpioController.OpenPin(pinNumber, PinMode.Output);
}
else if (_gpioController.GetPinMode(pinNumber) != PinMode.Output)
{
_gpioController.SetPinMode(pinNumber, PinMode.Output);
}
}
public RelayDevice(GpioController gpio, int pin)
{
_gpio = gpio;
_pin = pin;
// Ensure the pin is closed so the
// relay is off.
if (_gpio.IsPinOpen(_pin))
{
_gpio.ClosePin(_pin);
}
}
public Relay(GpioController gpioController, int inPin)
{
this.gpioController = gpioController;
InPin = inPin;
if (!gpioController.IsPinOpen(InPin))
{
gpioController.OpenPin(InPin);
}
gpioController.SetPinMode(InPin, PinMode.Output);
gpioController.Write(InPin, PinValue.High);
}
public void Open(WebServerEventArgs e)
{
try
{
var rawUrl = e.Context.Request.RawUrl.TrimStart('/');
var args = rawUrl.Split('/');
if (args.Length < 3)
{
WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.BadRequest);
return;
}
var pinNumber = Convert.ToInt32(args[1]);
if (!_controller.IsPinOpen(pinNumber))
{
_controller.OpenPin(pinNumber);
}
if (args[2].ToLower() == "output")
{
_controller.SetPinMode(pinNumber, PinMode.Output);
}
else if (args[2].ToLower() == "input")
{
_controller.SetPinMode(pinNumber, PinMode.Input);
}
else
{
WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.BadRequest);
return;
}
WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.OK);
}
catch (Exception)
{
WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.BadRequest);
}
}
static void Main(string[] args)
{
Console.WriteLine("Start!");
try
{
int pin = 7;
using (GpioController controller = new GpioController(PinNumberingScheme.Board))
{
//注册退出事件
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs eventArgs) =>
{
if (controller.IsPinOpen(pin))
{
controller.ClosePin(pin);
}
controller.Dispose();
Console.WriteLine("Close pin and exit successful!");
};
// 设置引脚
controller.OpenPin(pin, PinMode.Output);
if (!controller.IsPinOpen(pin))
{
Console.WriteLine($"Set pin {pin} output mode failed.");
}
while (true)
{
// 打开
controller.Write(pin, PinValue.High);
Thread.Sleep(500);
// 关闭
controller.Write(pin, PinValue.Low);
Thread.Sleep(500);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public PinDetails GetPinDetails(int pin)
{
var pinOpen = _gpioController.IsPinOpen(pin);
if (!pinOpen)
{
_gpioController.OpenPin(pin);
}
var details = new PinDetails()
{
PinNumber = pin,
IsOpen = pinOpen,
PinValue = (int)_gpioController.Read(pin),
PinMode = _gpioController.GetPinMode(pin)
};
if (!pinOpen)
{
_gpioController.ClosePin(pin);
}
return(details);
}
public LEDController(
ILogger <LEDController> logger,
GpioController controller
)
{
_controller = controller;
this.logger = logger;
if (!controller.IsPinOpen(ledPin))
{
controller.OpenPin(ledPin, PinMode.Output);
}
}
public void ReadSpan()
{
_mockedGpioDriver.Setup(x => x.OpenPinEx(1));
_mockedGpioDriver.Setup(x => x.OpenPinEx(2));
_mockedGpioDriver.Setup(x => x.IsPinModeSupportedEx(1, PinMode.Input)).Returns(true);
_mockedGpioDriver.Setup(x => x.IsPinModeSupportedEx(2, PinMode.Input)).Returns(true);
_mockedGpioDriver.Setup(x => x.ReadEx(1)).Returns(PinValue.Low);
_mockedGpioDriver.Setup(x => x.ReadEx(2)).Returns(PinValue.High);
_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.Input);
ctrl.OpenPin(2, PinMode.Input);
Assert.True(ctrl.IsPinOpen(1));
// Invalid usage (we need to prefill the array)
// Was this the intended use case?
Assert.Throws <InvalidOperationException>(() =>
{
Span <PinValuePair> wrongArg = stackalloc PinValuePair[2];
ctrl.Read(wrongArg);
});
Span <PinValuePair> toread = stackalloc PinValuePair[2];
toread[0] = new PinValuePair(1, PinValue.Low);
toread[1] = new PinValuePair(2, PinValue.Low);
ctrl.Read(toread);
Assert.Equal(1, toread[0].PinNumber);
Assert.Equal(2, toread[1].PinNumber);
Assert.Equal(PinValue.Low, toread[0].PinValue);
Assert.Equal(PinValue.High, toread[1].PinValue);
ctrl.ClosePin(1);
ctrl.ClosePin(2);
Assert.False(ctrl.IsPinOpen(1));
}
