private async Task PollAsync()
{
if (!IsPossible)
{
Logger.Log("An error occurred. Check if the specified pin is valid.", LogLevels.Warn);
return;
}
Config.SetEventRegisteredStatus(true);
await Sync.WaitAsync().ConfigureAwait(false);
Logger.Log($"Started '{(Config.PinMode == GpioPinMode.Input ? "Input" : "Output")}' pin polling for {Config.GpioPin}.", LogLevels.Trace);
try {
do
{
bool currentValue = Driver.GpioDigitalRead(Config.GpioPin);
GpioPinState currentState = currentValue ? GpioPinState.Off : GpioPinState.On;
OnPollResult(currentValue, currentState);
await Task.Delay(POLL_DELAY);
} while (!OverridePolling);
}
finally {
Config.SetEventRegisteredStatus(false);
Logger.Log($"Polling for '{Config.GpioPin}' has been stopped.", LogLevels.Trace);
Sync.Release();
}
}
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);
}
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;
}
}
}
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 PinValueBase(GpioPinState state, bool digitalValue, GpioPinMode pinMode, PinEventState eventState)
{
State = state;
DigitalValue = digitalValue;
PinMode = pinMode;
EventState = eventState;
}
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);
}
}
}
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);
}
}
private void OnPollResult(bool currentValue, GpioPinState currentState)
{
if (!IsPossible)
{
return;
}
bool isSame = PreviousValue.PinState == currentState;
Pin pinConfig = Driver.GetPinConfig(Config.GpioPin);
OnValueChangedEventArgs args;
switch (Config.PinEventState)
{
case PinEventStates.Activated when currentState == GpioPinState.On && !isSame:
args = new OnValueChangedEventArgs(Config.GpioPin, currentState, currentValue,
Config.PinMode, PinEventStates.Activated, PreviousValue.PinState, PreviousValue.DigitalValue);
Config.OnEvent?.Invoke(args);
break;
case PinEventStates.Deactivated when currentState == GpioPinState.Off && !isSame:
args = new OnValueChangedEventArgs(Config.GpioPin, currentState, currentValue,
Config.PinMode, PinEventStates.Deactivated, PreviousValue.PinState, PreviousValue.DigitalValue);
Config.OnEvent?.Invoke(args);
break;
case PinEventStates.Both when PreviousValue.PinState != currentState:
args = new OnValueChangedEventArgs(Config.GpioPin, currentState, currentValue,
Config.PinMode, PinEventStates.Both, PreviousValue.PinState, PreviousValue.DigitalValue);
Config.OnEvent?.Invoke(args);
break;
}
PreviousValue.Set(currentState, currentValue);
}
public Pin(int pin, GpioPinState state, bool available = true, string?jobName = null)
{
PinNumber = pin;
PinState = state;
IsAvailable = available;
JobName = jobName;
}
internal Pin(int pin, GpioPinState state, bool available = true, string?jobName = null)
{
PinNumber = pin;
PinState = state;
Mode = GpioPinMode.Input;
IsAvailable = available;
JobName = jobName;
}
public Pin(int pin, GpioPinMode mode, bool available = true, string?jobName = null)
{
PinNumber = pin;
PinState = GpioPinState.Off;
Mode = mode;
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;
}
private bool WriteValue(int pinNumber, GpioPinState state)
{
if (!PinController.IsValidPin(pinNumber))
{
return(false);
}
CommandLine.Execute(COMMAND_KEY + $" write {pinNumber} {(int) state}");
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;
}
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, 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);
}
public bool SetGpioValue(int pin, GpioPinState state)
{
if (!PiController.IsValidPin(pin))
{
return(false);
}
GpioPin GpioPin = (GpioPin)Pi.Gpio[pin];
if (GpioPin.PinMode == GpioPinDriveMode.Output)
{
GpioPin.Write((GpioPinValue)state);
Logger.Trace($"Configured ({pin}) gpio pin to ({state.ToString()}) state.");
return(true);
}
return(false);
}
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);
}
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);
}
/// <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);
}
private void OnProbeRecieved()
{
Console.WriteLine("StatusProbe RECIEVED ");
try
{
GpioDeviceState data = new GpioDeviceState();
for (int i = 1; i <= 40; i++)
{
GpioId currentPinId = GpioPinMapping.GetGpioId(i);
if (currentPinId != GpioId.GPIOUnknown)
{
//_manager.SelectPin (GpioPinMapping.GetGPIOId (i));
GpioPinState state = _manager.ReadFromPin(currentPinId);
data.GpioPinStates.Add(currentPinId, state);
//_manager.ReleasePin (currentPinId);
}
}
data.TimeStamp = DateTime.UtcNow.Ticks;
PiotHubProxy.Invoke <string>("CurrentStatus", data).ContinueWith(sendStatusTask =>
{
if (sendStatusTask.IsFaulted)
{
Console.WriteLine("There was an error opening the connection:{0}",
sendStatusTask.Exception.GetBaseException());
}
else
{
Console.WriteLine(string.Format("Probe data sent: {0}", new DateTime(data.TimeStamp).ToLongDateString()));
}
});
}
catch (Exception ex)
{
Console.WriteLine("Exception : {0}" + ex.Message);
}
}
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 GeneratedValue(GpioPinState _state, bool _digitalValue)
{
PinState = _state;
DigitalValue = _digitalValue;
}
public bool SetGpioValue(int pin, GpioPinState state)
{
throw new NotImplementedException();
}
internal void Set(GpioPinState _state, bool _digitalValue)
{
PinState = _state;
DigitalValue = _digitalValue;
}
internal void SetState(GpioPinState _state)
{
PinState = _state;
}
public void UpdatePinConfig(int pin, GpioPinMode mode, GpioPinState value, TimeSpan duration)
{
throw new NotImplementedException();
}
