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;
}
}
}
private void Update()
{
RaycastHit hit;
Vector3 fwd = transform.TransformDirection(Vector3.forward);
int mask = 1 << LayerMask.NameToLayer(excludeLayerName) | layerMaskInteract.value;
if (Physics.Raycast(transform.position, fwd, out hit, rayLength, mask))
{
if (hit.collider.CompareTag(interactableTag))
{
raycastedObj = hit.collider.gameObject.GetComponent <PiController>();
CrosshairChange(true);
isCrosshairActive = true;
crosshair.enabled = true;
doOnce = true;
if (Input.GetKeyDown(openDoorKey))
{
raycastedObj.Collect();
}
}
}
else
{
if (isCrosshairActive)
{
CrosshairChange(false);
doOnce = 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;
}
}
private static async Task DisplayConsoleCommandMenu()
{
Logger.Log("Displaying console command window", LogLevels.Trace);
Logger.Log($"------------------------- COMMAND WINDOW -------------------------", LogLevels.Input);
Logger.Log($"{Constants.ConsoleShutdownKey} - Shutdown assistant.", LogLevels.Input);
if (!PiController.IsAllowedToExecute)
{
Logger.Log($"{Constants.ConsoleRelayCommandMenuKey} - Display relay pin control menu.", LogLevels.Input);
Logger.Log($"{Constants.ConsoleRelayCycleMenuKey} - Display relay cycle control menu.", LogLevels.Input);
if (Config.EnableModules)
{
Logger.Log($"{Constants.ConsoleModuleShutdownKey} - Invoke shutdown method on all currently running modules.", LogLevels.Input);
}
Logger.Log($"{Constants.ConsoleMorseCodeKey} - Morse code generator for the specified text.", LogLevels.Input);
}
Logger.Log($"{Constants.ConsoleTestMethodExecutionKey} - Run preconfigured test methods or tasks.", LogLevels.Input);
if (WeatherClient != null)
{
Logger.Log($"{Constants.ConsoleWeatherInfoKey} - Get weather info of the specified location based on the pin code.", LogLevels.Input);
}
Logger.Log($"-------------------------------------------------------------------", LogLevels.Input);
Logger.Log("Awaiting user input: \n", LogLevels.Input);
int failedTriesCount = 0;
int maxTries = 3;
while (true)
{
if (failedTriesCount > maxTries)
{
Logger.Log($"Multiple wrong inputs. please start the command menu again by pressing {Constants.ConsoleCommandMenuKey} key.", LogLevels.Warn);
return;
}
char pressedKey = Console.ReadKey().KeyChar;
switch (pressedKey)
{
case Constants.ConsoleShutdownKey:
Logger.Log("Shutting down assistant...", LogLevels.Warn);
await Task.Delay(1000).ConfigureAwait(false);
await Exit(0).ConfigureAwait(false);
return;
case Constants.ConsoleRelayCommandMenuKey when !PiController.IsAllowedToExecute:
Logger.Log("Displaying relay command menu...", LogLevels.Warn);
DisplayRelayCommandMenu();
return;
case Constants.ConsoleRelayCycleMenuKey when !PiController.IsAllowedToExecute:
Logger.Log("Displaying relay cycle menu...", LogLevels.Warn);
await DisplayRelayCycleMenu().ConfigureAwait(false);
return;
case Constants.ConsoleRelayCommandMenuKey when PiController.IsAllowedToExecute:
case Constants.ConsoleRelayCycleMenuKey when PiController.IsAllowedToExecute:
Logger.Log("Assistant is running in an Operating system/Device which doesn't support GPIO pin controlling functionality.", LogLevels.Warn);
return;
case Constants.ConsoleMorseCodeKey when !PiController.IsAllowedToExecute:
if (PiController == null)
{
return;
}
Logger.Log("Enter text to convert to Morse: ");
string morseCycle = Console.ReadLine();
var morseTranslator = PiController.GetMorseTranslator();
if (morseTranslator == null || !morseTranslator.IsTranslatorOnline)
{
Logger.Warning("Morse translator is offline or unavailable.");
return;
}
await morseTranslator.RelayMorseCycle(morseCycle, Config.OutputModePins[0]).ConfigureAwait(false);
return;
case Constants.ConsoleWeatherInfoKey:
Logger.Log("Please enter the pin code of the location: ");
int counter = 0;
int pinCode;
while (true)
{
if (counter > 4)
{
Logger.Log("Failed multiple times. aborting...");
return;
}
try {
pinCode = Convert.ToInt32(Console.ReadLine());
break;
}
catch {
counter++;
Logger.Log("Please try again!", LogLevels.Warn);
continue;
}
}
if (string.IsNullOrEmpty(Config.OpenWeatherApiKey))
{
Logger.Warning("Weather api key cannot be null.");
return;
}
if (WeatherClient == null)
{
Logger.Warning("Weather client is not initiated.");
return;
}
WeatherResponse?response = await WeatherClient.GetWeather(Config.OpenWeatherApiKey, pinCode, "in").ConfigureAwait(false);
if (response == null)
{
Logger.Warning("Failed to fetch weather response.");
return;
}
Logger.Log($"------------ Weather information for {pinCode}/{response.LocationName} ------------", LogLevels.Green);
if (response.Data != null)
{
Logger.Log($"Temperature: {response.Data.Temperature}", LogLevels.Green);
Logger.Log($"Humidity: {response.Data.Humidity}", LogLevels.Green);
Logger.Log($"Pressure: {response.Data.Pressure}", LogLevels.Green);
}
if (response.Wind != null)
{
Logger.Log($"Wind speed: {response.Wind.Speed}", LogLevels.Green);
}
if (response.Location != null)
{
Logger.Log($"Latitude: {response.Location.Latitude}", LogLevels.Green);
Logger.Log($"Longitude: {response.Location.Longitude}", LogLevels.Green);
Logger.Log($"Location name: {response.LocationName}", LogLevels.Green);
}
return;
case Constants.ConsoleTestMethodExecutionKey:
Logger.Log("Executing test methods/tasks", LogLevels.Warn);
Logger.Log("Test method execution finished successfully!", LogLevels.Green);
return;
case Constants.ConsoleModuleShutdownKey when ModuleLoader.Modules.Count > 0 && Config.EnableModules:
Logger.Log("Shutting down all modules...", LogLevels.Warn);
ModuleLoader.OnCoreShutdown();
return;
case Constants.ConsoleModuleShutdownKey when ModuleLoader.Modules.Count <= 0:
Logger.Log("There are no modules to shutdown...");
return;
default:
if (failedTriesCount > maxTries)
{
Logger.Log($"Unknown key was pressed. ({maxTries - failedTriesCount} tries left)", LogLevels.Warn);
}
failedTriesCount++;
continue;
}
}
}
/// <summary>
/// This method starts up the assistant core.
/// After registration of very important events on Program.cs, control moves to here.
/// This is basically the entry point of the application.
/// </summary>
/// <param name="args">The startup arguments. (if any)</param>
/// <returns></returns>
public static async Task <bool> InitCore(string[] args)
{
if (File.Exists(Constants.TraceLogPath))
{
File.Delete(Constants.TraceLogPath);
}
Helpers.CheckMultipleProcess();
StartupTime = DateTime.Now;
if (Helpers.CheckForInternetConnection())
{
IsNetworkAvailable = true;
}
else
{
Logger.Log("No internet connection.", Enums.LogLevels.Warn);
Logger.Log($"Starting {AssistantName} in offline mode...");
IsNetworkAvailable = false;
}
Config = Config.LoadConfig();
RunningPlatform = Helpers.GetOsPlatform();
AssistantName = Config.AssistantDisplayName;
Logger.LogIdentifier = AssistantName;
Config.ProgramLastStartup = StartupTime;
Constants.LocalIP = Helpers.GetLocalIpAddress();
SecureLine = new SecureLineServer(IPAddress.Any, 7777);
SecureLine.StartSecureLine();
SendLocalIp(!Helpers.IsNullOrEmpty(Constants.LocalIP));
Helpers.SetFileSeperator();
Helpers.GenerateAsciiFromText(Config.AssistantDisplayName);
Constants.ExternelIP = Helpers.GetExternalIp();
File.WriteAllText("version.txt", Constants.Version.ToString());
if (Helpers.IsNullOrEmpty(Constants.ExternelIP))
{
Constants.ExternelIP = "Failed.";
}
Helpers.InBackgroundThread(SetConsoleTitle, "Console Title Updater", true);
Logger.Log($"X---------------- Starting {AssistantName} v{Constants.Version} ----------------X", Enums.LogLevels.Ascii);
ConfigWatcher.InitConfigWatcher();
ParseStartupArguments(args);
if (!Helpers.IsNullOrEmpty(Config.PushBulletApiKey))
{
PushBulletService = new PushBulletService(Config.PushBulletApiKey);
(bool status, UserDeviceListResponse currentPushDevices) = PushBulletService.InitPushService();
if (status)
{
Logger.Log("Push bullet service started.", Enums.LogLevels.Trace);
}
}
if (!Helpers.IsRaspberryEnvironment())
{
DisablePiMethods = true;
IsUnknownOs = true;
}
if (Helpers.GetOsPlatform().Equals(OSPlatform.Windows))
{
AssistantStatus = new ProcessStatus();
}
else
{
Logger.Log("Could not start performence counters as it is not supported on this platform.", Enums.LogLevels.Trace);
}
await Update.CheckAndUpdateAsync(true).ConfigureAwait(false);
if (Config.KestrelServer && !Helpers.IsNullOrEmpty(Config.KestrelServerUrl))
{
await KestrelServer.Start().ConfigureAwait(false);
}
ModuleLoader = new ModuleInitializer();
ModuleLoader.LoadAndStartModulesOfType <IModuleBase>();
ModuleWatcher.InitModuleWatcher();
Controller = new PiController(true);
CoreInitiationCompleted = true;
await PostInitTasks().ConfigureAwait(false);
return(true);
}
public GpioEventManager(PiController controller)
{
Controller = controller ?? throw new ArgumentNullException();
}
