public bool SetGpioValue(int pin, GpioPinState state)
{
if (!PinController.IsValidPin(pin))
{
return(false);
}
try {
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
if (GpioPin.PinMode == GpioPinDriveMode.Output)
{
GpioPin.Write((GpioPinValue)state);
CastDriver <IGpioControllerDriver>(this).Logger.Trace($"Configured ({pin}) gpio pin to ({state.ToString()}) state.");
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(new Pin(pin, state));
return(true);
}
return(false);
}
finally {
Pin?pinConfig = GetPinConfig(pin);
if (pinConfig != null)
{
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(pinConfig);
}
}
}
public bool GpioDigitalRead(int pin)
{
if (!IsWiringPiInstalled())
{
return(false);
}
if (!PiGpioController.IsAllowedToExecute || !IsDriverProperlyInitialized)
{
return(false);
}
if (!PinController.IsValidPin(pin))
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(false);
}
try {
return(ReadState(pin) == Enums.GpioPinState.Off ? false : true);
}
finally {
Pin?pinConfig = GetPinConfig(pin);
if (pinConfig != null)
{
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(pinConfig);
}
}
}
private void OnEventResult(ref PinEventConfiguration config)
{
if (config == null || !PinController.IsValidPin(config.GpioPin))
{
return;
}
if (config.Current.Equals(config.Previous))
{
return;
}
OnValueChangedEventArgs onValueChangedEventArgs = new OnValueChangedEventArgs(config.GpioPin, (CurrentValue)config.Current, (PreviousValue)config.Previous);
switch (config.EventState)
{
case PinEventState.Activated when config.Current.DigitalValue:
OnActivatedEventArgs onActivatedEventArgs = new OnActivatedEventArgs(config.GpioPin, (CurrentValue)config.Current);
ParallelExecuteOnEach(config.EventState, (p) => p.OnActivated(this, onActivatedEventArgs)).RunSynchronously();
break;
case PinEventState.Deactivated when !config.Current.DigitalValue:
OnDeactivatedEventArgs onDeactivatedEventArgs = new OnDeactivatedEventArgs(config.GpioPin, (CurrentValue)config.Current);
ParallelExecuteOnEach(config.EventState, (p) => p.OnDeactivated(this, onDeactivatedEventArgs)).RunSynchronously();
break;
case PinEventState.Both:
break;
}
ParallelExecuteOnEach(config.EventState, (p) => p.OnValueChanged(this, onValueChangedEventArgs)).RunSynchronously();
}
internal override bool SetGpioValue(int pin, GpioPinState state)
{
if (!IsWiringPiInstalled())
{
return(false);
}
if (!GpioCore.IsAllowedToExecute || !IsDriverInitialized)
{
return(false);
}
if (!PinController.IsValidPin(pin))
{
return(false);
}
Pin pinConfig = GetPinConfig(pin);
if (pinConfig.Mode != GpioPinMode.Output)
{
return(false);
}
return(WriteValue(pin, state));
}
internal override bool GpioDigitalRead(int pin)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(false);
}
try {
if (DriverController == null)
{
return(false);
}
if (!DriverController.IsPinOpen(pin))
{
DriverController.OpenPin(pin);
}
if (!DriverController.IsPinOpen(pin))
{
return(false);
}
return(!(DriverController.Read(pin) == PinValue.High));
}
finally {
ClosePin(pin);
}
}
public bool RegisterEvent(EventConfig config)
{
if (!PinController.IsValidPin(config.GpioPin))
{
Logger.Warning("The specified pin is invalid.");
return(false);
}
Generator gen = new Generator(config);
gen.Poll();
for (int i = 0; i < 5; i++)
{
if (gen.IsEventRegistered)
{
break;
}
Task.Delay(30).Wait();
}
if (!gen.IsEventRegistered)
{
return(false);
}
Events.Add(config.GpioPin, gen);
return(gen.IsEventRegistered);
}
internal override int GpioPhysicalPinNumber(int bcmPin)
{
if (!PinController.IsValidPin(bcmPin) || !IsDriverInitialized)
{
return(-1);
}
try {
if (DriverController == null)
{
return(-1);
}
if (!DriverController.IsPinOpen(bcmPin))
{
DriverController.OpenPin(bcmPin);
}
if (!DriverController.IsPinOpen(bcmPin))
{
return(-1);
}
return(-1);
}
finally {
ClosePin(bcmPin);
}
}
internal override bool SetGpioValue(int pin, GpioPinState state)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(false);
}
try {
if (DriverController == null)
{
return(false);
}
if (!DriverController.IsPinOpen(pin))
{
DriverController.OpenPin(pin);
}
if (!DriverController.IsPinOpen(pin))
{
return(false);
}
DriverController.Write(pin, state == GpioPinState.Off ? PinValue.High : PinValue.Low);
return(true);
}
finally {
ClosePin(pin);
}
}
internal override bool SetGpioValue(int pin, GpioPinMode mode)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(false);
}
try {
if (DriverController == null)
{
return(false);
}
if (!DriverController.IsPinModeSupported(pin, (PinMode)mode))
{
return(false);
}
if (!DriverController.IsPinOpen(pin))
{
DriverController.OpenPin(pin);
}
if (!DriverController.IsPinOpen(pin))
{
return(false);
}
DriverController.SetPinMode(pin, (PinMode)mode);
return(true);
}
finally {
ClosePin(pin);
}
}
internal override Pin GetPinConfig(int pinNumber)
{
if (!PinController.IsValidPin(pinNumber) || DriverController == null || !IsDriverInitialized)
{
return(new Pin());
}
if (DriverController == null)
{
return(new Pin());
}
try {
if (!DriverController.IsPinOpen(pinNumber))
{
DriverController.OpenPin(pinNumber);
}
if (!DriverController.IsPinOpen(pinNumber))
{
return(new Pin());
}
PinValue value = DriverController.Read(pinNumber);
PinMode mode = DriverController.GetPinMode(pinNumber);
Pin config = new Pin(pinNumber, value == PinValue.High ? GpioPinState.Off : GpioPinState.On, mode == PinMode.Input ? GpioPinMode.Input : GpioPinMode.Output);
return(config);
}
finally {
ClosePin(pinNumber);
}
}
public bool SetGpioValue(int pin, Enums.GpioPinMode mode, Enums.GpioPinState state)
{
if (!IsWiringPiInstalled())
{
return(false);
}
if (!PiGpioController.IsAllowedToExecute || !IsDriverProperlyInitialized)
{
return(false);
}
if (!PinController.IsValidPin(pin))
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(false);
}
try {
if (SetMode(pin, mode))
{
return(WriteValue(pin, state));
}
return(false);
}
finally {
Pin?pinConfig = GetPinConfig(pin);
if (pinConfig != null)
{
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(pinConfig);
}
}
}
public int GpioPhysicalPinNumber(int bcmPin)
{
if (!PinController.IsValidPin(bcmPin) || !IsDriverProperlyInitialized)
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(-1);
}
try {
if (DriverController == null)
{
return(-1);
}
DriverController.OpenPin(bcmPin);
if (!DriverController.IsPinOpen(bcmPin))
{
return(-1);
}
CastDriver <IGpioControllerDriver>(this)?.Logger.Info("System.Devices.Gpio driver doesn't support PhysicalPinNumber conversion.");
return(-1);
}
finally {
if (DriverController != null)
{
if (DriverController.IsPinOpen(bcmPin))
{
DriverController.ClosePin(bcmPin);
}
}
}
}
internal override GpioPinState GpioPinStateRead(int pin)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(GpioPinState.Off);
}
try {
if (DriverController == null)
{
return(GpioPinState.Off);
}
if (!DriverController.IsPinOpen(pin))
{
DriverController.OpenPin(pin);
}
if (!DriverController.IsPinOpen(pin))
{
return(GpioPinState.Off);
}
return(DriverController.Read(pin) == PinValue.High ? GpioPinState.Off : GpioPinState.On);
}
finally {
ClosePin(pin);
}
}
internal override bool GpioDigitalRead(int pin)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(false);
}
return(((GpioPin)Pi.Gpio[pin]).Read());
}
private bool WriteValue(int pinNumber, GpioPinState state)
{
if (!PinController.IsValidPin(pinNumber))
{
return(false);
}
CommandLine.Execute(COMMAND_KEY + $" write {pinNumber} {(int) state}");
return(true);
}
public bool TogglePinState(int pinNumber)
{
if (!PinController.IsValidPin(pinNumber))
{
return(false);
}
(COMMAND_KEY + $" toggle {pinNumber}").ExecuteBash(false);
return(true);
}
internal override bool TogglePinState(int pinNumber)
{
if (!PinController.IsValidPin(pinNumber))
{
return(false);
}
CommandLine.Execute(COMMAND_KEY + $" toggle {pinNumber}");
return(true);
}
private bool TogglePin(int pinNumber)
{
if (!PinController.IsValidPin(pinNumber))
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(false);
}
(COMMAND_KEY + $" toggle {pinNumber}").ExecuteBash(false);
return(true);
}
private bool WriteValue(int pinNumber, Enums.GpioPinState state)
{
if (!PinController.IsValidPin(pinNumber))
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(false);
}
(COMMAND_KEY + $" write {pinNumber} {(int) state}").ExecuteBash(false);
return(true);
}
internal override int GpioPhysicalPinNumber(int bcmPin)
{
if (!PinController.IsValidPin(bcmPin))
{
return(-1);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[bcmPin];
return(GpioPin.PhysicalPinNumber);
}
internal override GpioPinState GpioPinStateRead(int pin)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(GpioPinState.Off);
}
GpioPin gpioPin = (GpioPin)Pi.Gpio[pin];
return((GpioPinState)gpioPin.ReadValue());
}
private bool SetMode(int pinNumber, GpioPinMode mode)
{
if (!PinController.IsValidPin(pinNumber))
{
return(false);
}
string pinMode = mode == GpioPinMode.Input ? "in" : "out";
CommandLine.Execute(COMMAND_KEY + $" mode {pinNumber} {pinMode}");
return(true);
}
private void ClosePin(int pinNumber)
{
if (DriverController == null)
{
return;
}
if (PinController.IsValidPin(pinNumber) && DriverController.IsPinOpen(pinNumber))
{
DriverController.ClosePin(pinNumber);
}
}
internal override bool SetGpioValue(int pin, GpioPinMode mode)
{
if (!PinController.IsValidPin(pin))
{
return(false);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
GpioPin.PinMode = (GpioPinDriveMode)mode;
return(true);
}
public int GpioPhysicalPinNumber(int bcmPin)
{
if (!PinController.IsValidPin(bcmPin))
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(0);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[bcmPin];
return(GpioPin.PhysicalPinNumber);
}
private bool SetMode(int pinNumber, Enums.GpioPinMode mode)
{
if (!PinController.IsValidPin(pinNumber))
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Log("The specified pin is invalid.");
return(false);
}
string pinMode = mode == Enums.GpioPinMode.Input ? "in" : "out";
(COMMAND_KEY + $" mode {pinNumber} {pinMode}").ExecuteBash(false);
return(true);
}
public Pin?GetPinConfig(int pinNumber)
{
if (!PinController.IsValidPin(pinNumber) || DriverController == null || !IsDriverProperlyInitialized)
{
return(null);
}
PinValue value = DriverController.Read(pinNumber);
PinMode mode = DriverController.GetPinMode(pinNumber);
Pin config = new Pin(pinNumber, value == PinValue.High ? GpioPinState.Off : GpioPinState.On, mode == PinMode.Input ? GpioPinMode.Input : GpioPinMode.Output);
return(config);
}
internal override Pin GetPinConfig(int pinNumber)
{
if (!GpioCore.IsAllowedToExecute || !IsDriverInitialized)
{
return(new Pin());
}
if (!PinController.IsValidPin(pinNumber))
{
return(new Pin());
}
GpioPin pin = (GpioPin)Pi.Gpio[pinNumber];
return(new Pin(pinNumber, (GpioPinState)pin.ReadValue(), (GpioPinMode)pin.PinMode));
}
public bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state)
{
if (!PinController.IsValidPin(pin) || !IsDriverProperlyInitialized)
{
return(false);
}
try {
if (DriverController == null)
{
return(false);
}
if (!DriverController.IsPinModeSupported(pin, (PinMode)mode))
{
return(false);
}
DriverController.OpenPin(pin);
if (!DriverController.IsPinOpen(pin))
{
return(false);
}
DriverController.SetPinMode(pin, (PinMode)mode);
DriverController.Write(pin, state == GpioPinState.Off ? PinValue.High : PinValue.Low);
CastDriver <IGpioControllerDriver>(this)?.Logger.Trace($"Configured ({pin}) gpio pin to ({state.ToString()}) state with ({mode.ToString()}) mode.");
CastDriver <IGpioControllerDriver>(this)?.UpdatePinConfig(new Pin(pin, state, mode));
return(true);
}
finally {
if (DriverController != null)
{
if (DriverController.IsPinOpen(pin))
{
DriverController.ClosePin(pin);
}
}
Pin?pinConfig = GetPinConfig(pin);
if (pinConfig != null)
{
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(pinConfig);
}
}
}
internal override bool SetGpioValue(int pin, GpioPinState state)
{
if (!PinController.IsValidPin(pin))
{
return(false);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
if (GpioPin.PinMode != GpioPinDriveMode.Output)
{
return(false);
}
GpioPin.Write((GpioPinValue)state);
return(true);
}
