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