public void UpdatePinConfig(int pin, GpioPinMode mode, GpioPinState value, TimeSpan duration)
{
if (!PiController.IsValidPin(pin))
{
Logger.Log("The specified pin is invalid.");
return;
}
if (PiController.PinConfigCollection.Count <= 0)
{
return;
}
foreach (GpioPinConfig config in PiController.PinConfigCollection)
{
if (config.Pin == pin)
{
config.IsDelayedTaskSet = duration != TimeSpan.Zero;
config.TaskSetAfterMinutes = duration != TimeSpan.Zero ? duration.Minutes : 0;
config.Mode = mode;
config.PinValue = value;
break;
}
}
}
public bool SetGpioWithTimeout(int pin, GpioPinMode mode, GpioPinState state, TimeSpan duration)
{
if (!PiController.IsValidPin(pin))
{
Logger.Log("The specified pin is invalid.");
return(false);
}
if (PiController.PinConfigCollection.Count > 0 && PiController.PinConfigCollection.Where(x => x.Pin == pin && x.IsDelayedTaskSet).Any())
{
return(false);
}
if (SetGpioValue(pin, mode, state))
{
UpdatePinConfig(pin, mode, state, duration);
Extensions.Helpers.ScheduleTask(() => {
if (SetGpioValue(pin, mode, GpioPinState.Off))
{
UpdatePinConfig(pin, mode, GpioPinState.Off, TimeSpan.Zero);
}
}, duration);
return(true);
}
return(false);
}
internal PinValueBase(GpioPinState state, bool digitalValue, GpioPinMode pinMode, PinEventState eventState)
{
State = state;
DigitalValue = digitalValue;
PinMode = pinMode;
EventState = eventState;
}
protected virtual async Task <bool> ExecuteOnEachPin(IEnumerable <int> pins, GpioPinMode setMode, GpioPinState setPinState, int delayInMs = 100)
{
if (pins == null || pins.Count() <= 0)
{
return(false);
}
foreach (int pin in pins)
{
if (!Pins.OutputPins.Contains(pin) || !PreExecValidation(pin))
{
continue;
}
Pin pinConfig = GetPinConfig(pin);
if (pinConfig.Mode != setMode)
{
SetGpioValue(pin, setMode);
}
if (pinConfig.PinState != setPinState)
{
SetGpioValue(pin, setPinState);
}
await Task.Delay(delayInMs).ConfigureAwait(false);
}
return(true);
}
public EventConfig(int _gpioPin, GpioPinMode _pinMode, GpioPinEventStates _pinEventState, Action <object, OnValueChangedEventArgs> _func)
{
GpioPin = _gpioPin;
PinMode = _pinMode;
PinEventState = _pinEventState;
OnFireAction = _func;
}
public bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state)
{
if (!PinController.IsValidPin(pin) || !IsDriverProperlyInitialized)
{
return(false);
}
try {
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
GpioPin.PinMode = (GpioPinDriveMode)mode;
if (mode == GpioPinMode.Output)
{
GpioPin.Write((GpioPinValue)state);
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);
}
CastDriver <IGpioControllerDriver>(this)?.Logger.Trace($"Configured ({pin}) gpio pin with ({mode.ToString()}) mode.");
CastDriver <IGpioControllerDriver>(this)?.UpdatePinConfig(new Pin(pin, mode));
return(true);
}
finally {
Pin?pinConfig = GetPinConfig(pin);
if (pinConfig != null)
{
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(pinConfig);
}
}
}
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);
}
}
private async Task <bool> ExecuteOnEachPin(IEnumerable <int> pins, GpioPinMode setMode, GpioPinState setPinState, int delayInMs = 100)
{
if (pins == null || pins.Count() <= 0)
{
return(false);
}
foreach (int pin in pins)
{
GpioPinConfig?pinConfig = GetGpioConfig(pin);
if (pinConfig == null)
{
continue;
}
if (pinConfig.Mode != setMode)
{
SetGpioValue(pin, setMode);
}
if (pinConfig.PinValue != setPinState)
{
SetGpioValue(pin, setPinState);
}
await Task.Delay(delayInMs).ConfigureAwait(false);
}
return(true);
}
public Pin(int pin, GpioPinMode mode, bool available = true, string?jobName = null)
{
PinNumber = pin;
Mode = mode;
IsAvailable = available;
JobName = jobName;
}
internal Pin(int pin, GpioPinMode mode, bool available = true, string?jobName = null)
{
PinNumber = pin;
PinState = GpioPinState.Off;
Mode = mode;
IsAvailable = available;
JobName = jobName;
}
internal EventConfig(int _gpioPin, GpioPinMode _pinMode, PinEventStates _pinEventState, Func <OnValueChangedEventArgs, bool> _onEvent)
{
GpioPin = _gpioPin;
PinMode = _pinMode;
PinEventState = _pinEventState;
IsEventRegistered = false;
OnEvent = _onEvent;
}
public Pin(int pin, GpioPinState state, bool available = true, string?jobName = null)
{
PinNumber = pin;
PinState = state;
Mode = GpioPinMode.Input;
IsAvailable = available;
JobName = jobName;
}
public GpioPinConfig(int _pin, GpioPinState _pinValue, GpioPinMode _mode, bool _isDelayedTaskSet, int _taskSetAfterMinutes)
{
this.Pin = _pin;
PinValue = _pinValue;
this.Mode = _mode;
IsDelayedTaskSet = _isDelayedTaskSet;
TaskSetAfterMinutes = _taskSetAfterMinutes;
}
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);
}
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);
}
public OnValueChangedEventArgs(int _pinNumber, GpioPinState _pinState,
bool _pinCurrentDigitalValue, GpioPinMode _pinDriveMode,
GpioPinState _previousPinState, bool _previousDigitalValue)
{
Pin = _pinNumber;
CurrentState = _pinState;
CurrentDigitalValue = _pinCurrentDigitalValue;
CurrentMode = _pinDriveMode;
EventTime = DateTime.Now;
PreviousPinState = _previousPinState;
PreviousDigitalValue = _previousDigitalValue;
}
public GpioPinValueChangedEventArgs(int _pinNumber, GpioPinState _pinState,
GpioPinState _pinPreviousState, bool _pinCurrentDigitalValue, bool _pinPreviousDigitalValue,
GpioPinMode _pinDriveMode, int _gpioPhysicalPinNumber)
{
PinNumber = _pinNumber;
PinState = _pinState;
PinPreviousState = _pinPreviousState;
PinCurrentDigitalValue = _pinCurrentDigitalValue;
PinPreviousDigitalValue = _pinPreviousDigitalValue;
PinDriveMode = _pinDriveMode;
GpioPhysicalPinNumber = _gpioPhysicalPinNumber;
}
public bool SetGpioValue(int pin, GpioPinMode mode)
{
if (!PiController.IsValidPin(pin))
{
return(false);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
GpioPin.PinMode = (GpioPinDriveMode)mode;
Logger.Trace($"Configured ({pin}) gpio pin with ({mode.ToString()}) mode.");
return(true);
}
internal OnValueChangedEventArgs(int _pinNumber, GpioPinState _pinState,
bool _pinCurrentDigitalValue, GpioPinMode _pinDriveMode, PinEventStates _state,
GpioPinState _previousPinState, bool _previousDigitalValue)
{
Pin = _pinNumber;
CurrentState = _pinState;
CurrentDigitalValue = _pinCurrentDigitalValue;
CurrentMode = _pinDriveMode;
TimeStamp = DateTime.Now;
PreviousPinState = _previousPinState;
PreviousDigitalValue = _previousDigitalValue;
CurrentEventState = _state;
}
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, GpioPinMode mode, GpioPinState state)
{
if (!PinController.IsValidPin(pin) || !IsDriverInitialized)
{
return(false);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
GpioPin.PinMode = (GpioPinDriveMode)mode;
if (mode == GpioPinMode.Output)
{
GpioPin.Write((GpioPinValue)state);
return(true);
}
return(true);
}
internal override bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state)
{
if (!IsWiringPiInstalled())
{
return(false);
}
if (!GpioCore.IsAllowedToExecute || !IsDriverInitialized)
{
return(false);
}
if (!PinController.IsValidPin(pin))
{
return(false);
}
return(SetMode(pin, mode) ? WriteValue(pin, state) : false);
}
public bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state)
{
if (!PiController.IsValidPin(pin))
{
return(false);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
GpioPin.PinMode = (GpioPinDriveMode)mode;
if (mode == GpioPinMode.Output)
{
GpioPin.Write((GpioPinValue)state);
Logger.Trace($"Configured ({pin}) gpio pin to ({state.ToString()}) state with ({mode.ToString()}) mode.");
return(true);
}
Logger.Trace($"Configured ({pin}) gpio pin with ({mode.ToString()}) mode.");
return(true);
}
/// <summary>
/// Sets the specified pin to specified mode and state for duration TimeSpan, after which, the pin will return to its previous state.
/// <br><b>NOTE: This will block the calling thread until the timespan expires.</b></br>
/// </summary>
/// <param name="pin">The pin to configure</param>
/// <param name="mode">The mode to set the pin into</param>
/// <param name="state">The state to set the pin into</param>
/// <param name="duration">The TimeSpan duration after which the pin returns to the initial state</param>
/// <param name="shouldBlockThread">Specifies if the method should wait until the duration expires.</param>
/// <returns>Status of the configuration</returns>
internal virtual bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state, TimeSpan duration, bool shouldBlockThread = false)
{
if (!PreExecValidation(pin))
{
return(false);
}
if (SetGpioValue(pin, mode, state))
{
bool set = false;
Helpers.ScheduleTask(() => {
SetGpioValue(pin, mode, GpioPinState.Off);
set = true;
}, duration);
Helpers.WaitWhile(() => shouldBlockThread && !set);
return(true);
}
return(false);
}
public bool SetGpioValue(int pin, GpioPinMode mode)
{
if (!PinController.IsValidPin(pin))
{
return(false);
}
try {
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
GpioPin.PinMode = (GpioPinDriveMode)mode;
CastDriver <IGpioControllerDriver>(this)?.Logger.Trace($"Configured ({pin}) gpio pin with ({mode.ToString()}) mode.");
CastDriver <IGpioControllerDriver>(this)?.UpdatePinConfig(new Pin(pin, mode));
return(true);
}
finally {
Pin?pinConfig = GetPinConfig(pin);
if (pinConfig != null)
{
CastDriver <IGpioControllerDriver>(this).UpdatePinConfig(pinConfig);
}
}
}
public bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state)
{
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);
DriverController.Write(pin, state == GpioPinState.Off ? PinValue.High : PinValue.Low);
return(true);
}
finally {
ClosePin(pin);
}
}
public bool SetGpioWithTimeout(int pin, GpioPinMode mode, GpioPinState state, TimeSpan duration)
{
throw new NotImplementedException();
}
internal PreviousValue(GpioPinState state, bool digitalValue, GpioPinMode pinMode, PinEventState eventState) : base(state, digitalValue, pinMode, eventState)
{
}
public bool SetGpioValue(int pin, GpioPinMode mode, GpioPinState state)
{
throw new NotImplementedException();
}
public void UpdatePinConfig(int pin, GpioPinMode mode, GpioPinState value, TimeSpan duration)
{
throw new NotImplementedException();
}
