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);
}
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);
}
public GpioPinConfig GetGpioConfig(int pinNumber)
{
if (!PiController.IsValidPin(pinNumber) || Controller == null)
{
return(new GpioPinConfig());
}
PinValue value = Controller.Read(pinNumber);
PinMode mode = Controller.GetPinMode(pinNumber);
GpioPinConfig config = new GpioPinConfig(pinNumber, value == PinValue.High ? GpioPinState.Off : GpioPinState.On, mode == PinMode.Input ? GpioPinMode.Input : GpioPinMode.Output, false, 0);
return(config);
}
public GpioPinConfig GetGpioConfig(int pinNumber)
{
if (!PiController.IsAllowedToExecute || !IsDriverProperlyInitialized)
{
return(new GpioPinConfig());
}
if (!PiController.IsValidPin(pinNumber))
{
Logger.Log("The specified pin is invalid.");
return(new GpioPinConfig());
}
GpioPin pin = (GpioPin)Pi.Gpio[pinNumber];
return(new GpioPinConfig(pinNumber, (GpioPinState)pin.ReadValue(), (GpioPinMode)pin.PinMode, false, 0));
}
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);
}
private async Task ProcessOnReceived(BaseRequest request)
{
switch (request.TypeCode)
{
case TYPE_CODE.EVENT_PIN_STATE:
break;
case TYPE_CODE.UNKNOWN:
break;
case TYPE_CODE.SET_ALARM:
break;
case TYPE_CODE.SET_GPIO:
if (string.IsNullOrEmpty(request.RequestObject))
{
return;
}
SetGpioRequest setGpioRequest = JsonConvert.DeserializeObject <SetGpioRequest>(request.RequestObject);
if (!PiController.IsValidPin(setGpioRequest.PinNumber))
{
return;
}
if (Core.PiController == null || !Core.PiController.IsControllerProperlyInitialized || Core.PinController == null)
{
return;
}
if (Client == null || Client.IsDisposed)
{
return;
}
if (Core.PinController.SetGpioValue(setGpioRequest.PinNumber, (GpioPinMode)setGpioRequest.PinMode, (GpioPinState)setGpioRequest.PinState))
{
GpioPinConfig config = Core.PinController.GetGpioConfig(setGpioRequest.PinNumber);
if (await Client.SendAsync(new BaseResponse(DateTime.Now, TYPE_CODE.SET_GPIO, "Success!", GpioPinConfig.AsJson(config))).ConfigureAwait(false))
{
Logger.Log($"{request.TypeCode.ToString()} response send!", LogLevels.Trace);
return;
}
}
await Client.SendAsync(new BaseResponse(DateTime.Now, TYPE_CODE.SET_GPIO, "Failed.", string.Empty)).ConfigureAwait(false);
break;
case TYPE_CODE.SET_GPIO_DELAYED:
if (string.IsNullOrEmpty(request.RequestObject))
{
return;
}
SetGpioDelayedRequest setGpioDelayedRequest = JsonConvert.DeserializeObject <SetGpioDelayedRequest>(request.RequestObject);
if (!PiController.IsValidPin(setGpioDelayedRequest.PinNumber))
{
return;
}
if (Core.PiController == null || !Core.PiController.IsControllerProperlyInitialized || Core.PinController == null)
{
return;
}
if (Client == null || Client.IsDisposed)
{
return;
}
if (Core.PinController.SetGpioWithTimeout(setGpioDelayedRequest.PinNumber, (GpioPinMode)setGpioDelayedRequest.PinMode, (GpioPinState)setGpioDelayedRequest.PinState, TimeSpan.FromMinutes(setGpioDelayedRequest.Delay)))
{
GpioPinConfig config = Core.PinController.GetGpioConfig(setGpioDelayedRequest.PinNumber);
if (await Client.SendAsync(new BaseResponse(DateTime.Now, TYPE_CODE.SET_GPIO_DELAYED, "Success!", GpioPinConfig.AsJson(config))).ConfigureAwait(false))
{
Logger.Log($"{request.TypeCode.ToString()} response send!", LogLevels.Trace);
return;
}
}
await Client.SendAsync(new BaseResponse(DateTime.Now, TYPE_CODE.SET_GPIO_DELAYED, "Failed.", string.Empty)).ConfigureAwait(false);
break;
case TYPE_CODE.SET_REMAINDER:
break;
case TYPE_CODE.GET_GPIO:
break;
case TYPE_CODE.GET_GPIO_PIN:
break;
case TYPE_CODE.GET_WEATHER:
break;
case TYPE_CODE.GET_ASSISTANT_INFO:
break;
case TYPE_CODE.GET_PI_INFO:
break;
case TYPE_CODE.SET_PI:
break;
case TYPE_CODE.SET_ASSISTANT:
break;
default:
break;
}
}
