internal async Task InitController(GpioControllerDriver?driver, NumberingScheme numberingScheme)
{
if (IsInitSuccess || driver == null)
{
return;
}
if (!IsAllowedToExecute)
{
Logger.Warn("Running OS platform is unsupported.");
return;
}
PinController.InitPinController(driver);
GpioControllerDriver?gpioDriver = PinController.GetDriver();
if (driver == null || !driver.IsDriverInitialized)
{
Logger.Warn($"{gpioDriver.DriverName} failed to initialize properly. Restart of entire application is recommended.");
throw new DriverInitializationFailedException(gpioDriver.DriverName.ToString());
}
if (!await PinConfig.LoadConfiguration().ConfigureAwait(false))
{
GeneratePinConfiguration();
await PinConfig.SaveConfig().ConfigureAwait(false);
}
EventGenerator.InitEventGeneration();
IsInitSuccess = true;
}
public IGpioControllerDriver InitDriver(ILogger _logger, AvailablePins _availablePins, NumberingScheme _scheme)
{
Logger = _logger ?? throw new ArgumentNullException(nameof(_logger));
AvailablePins = _availablePins;
if (!IsWiringPiInstalled())
{
throw new DriverInitializationFailedException(nameof(WiringPiDriver), "WiringPi Library isn't installed on the system.");
}
if (!GpioCore.IsAllowedToExecute)
{
IsDriverInitialized = false;
throw new DriverInitializationFailedException(nameof(WiringPiDriver), "Driver isn't allowed to execute.");
}
NumberingScheme = _scheme;
//for (int i = 0; i < AvailablePins.OutputPins.Length; i++) {
// SetMode(AvailablePins.OutputPins[i], GpioPinMode.Output);
//}
//for (int i = 0; i < AvailablePins.InputPins.Length; i++) {
// SetMode(AvailablePins.InputPins[i], GpioPinMode.Input);
//}
IsDriverInitialized = true;
return(this);
}
public async Task InitController <T>(T selectedDriver, NumberingScheme _scheme) where T : IGpioControllerDriver
{
if (IsAlreadyInit)
{
return;
}
PreInit();
if (!IsAllowedToExecute)
{
Logger.Warning("Running OS platform is unsupported.");
return;
}
PinController.InitPinController <T>(selectedDriver, _scheme);
IGpioControllerDriver?driver = PinController.GetDriver();
if (driver == null || !driver.IsDriverInitialized)
{
Logger.Warning($"{selectedDriver.DriverName} failed to initialize properly. Restart of entire application is recommended.");
return;
}
await InitPinConfigs().ConfigureAwait(false);
await SetEvents().ConfigureAwait(false);
IsAlreadyInit = true;
}
/// <summary>
/// Initializes the gpio driver.
/// </summary>
/// <param name="pins">The available pins on the device.</param>
/// <param name="scheme">The numbering scheme to use.</param>
/// <returns>The driver.</returns>
internal GpioControllerDriver(InternalLogger logger, PinsWrapper pins, GpioDriver driverName, PinConfig pinConfig, NumberingScheme scheme)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
Pins = pins;
NumberingScheme = scheme;
DriverName = driverName;
PinConfig = pinConfig;
IsDriverInitialized = true;
}
public IGpioControllerDriver InitDriver(NumberingScheme numberingScheme)
{
if (!PiGpioController.IsAllowedToExecute)
{
CastDriver <IGpioControllerDriver>(this).Logger.Warning("Failed to initialize Gpio Controller Driver.");
IsDriverProperlyInitialized = false;
return(null);
}
NumberingScheme = numberingScheme;
DriverController = new GpioController((PinNumberingScheme)numberingScheme);
IsDriverProperlyInitialized = true;
return(this);
}
public IGpioControllerDriver InitDriver(NumberingScheme scheme)
{
if (!PiGpioController.IsAllowedToExecute)
{
CastDriver <IGpioControllerDriver>(this)?.Logger.Warning("Failed to initialize Gpio Controller Driver. (Driver isn't allowed to execute.)");
IsDriverProperlyInitialized = false;
return(this);
}
NumberingScheme = scheme;
Pi.Init <BootstrapWiringPi>();
IsDriverProperlyInitialized = true;
return(this);
}
public IGpioControllerDriver InitDriver(ILogger _logger, AvailablePins _availablePins, NumberingScheme _scheme)
{
Logger = _logger ?? throw new ArgumentNullException(nameof(_logger));
AvailablePins = _availablePins;
if (!GpioCore.IsAllowedToExecute)
{
IsDriverInitialized = false;
throw new DriverInitializationFailedException(nameof(RaspberryIODriver), "Not allowed to initialize.");
}
NumberingScheme = _scheme;
Pi.Init <BootstrapWiringPi>();
IsDriverInitialized = true;
return(this);
}
public SystemDeviceDriver(InternalLogger logger, PinsWrapper pins, PinConfig pinConfig, NumberingScheme scheme) : base(logger, pins, Enums.GpioDriver.SystemDevicesDriver, pinConfig, scheme)
{
}
internal WiringPiDriver(InternalLogger logger, PinsWrapper pins, PinConfig pinConfig, NumberingScheme scheme) : base(logger, pins, GpioDriver.WiringPiDriver, pinConfig, scheme)
{
CommandLine = new OSCommandLineInterfacer(OSPlatform.Linux, false, false, false);
}
internal RaspberryIODriver(InternalLogger logger, PinsWrapper pins, PinConfig pinConfig, NumberingScheme scheme) : base(logger, pins, GpioDriver.RaspberryIODriver, pinConfig, scheme)
{
}
public async Task InitController(IGpioControllerDriver?_driver, bool isUnixSys, NumberingScheme _scheme)
{
if (IsInitSuccess || _driver == null)
{
return;
}
IsAllowedToExecute = isUnixSys && Helpers.GetPlatform() == OSPlatform.Linux;
if (!IsAllowedToExecute)
{
Logger.Warning("Running OS platform is unsupported.");
return;
}
PinController.InitPinController(_driver, _scheme);
IGpioControllerDriver?driver = PinController.GetDriver();
if (driver == null || !driver.IsDriverInitialized)
{
Logger.Warning($"{_driver.DriverName} failed to initialize properly. Restart of entire application is recommended.");
throw new DriverInitializationFailedException(_driver.DriverName.ToString());
}
GeneratePinConfiguration(driver);
await InitEvents().ConfigureAwait(false);
IsInitSuccess = true;
}
//Method Name: assignGridOrdering
//Objectives: gives each block in the grid a number according to the numbering scheme used
//Inputs: an array of the (x, y, z) grid dimensions and an array of the Inactive blocks numberings
//Ouputs: an array of GridBlocks that are given numbers according to the numbering scheme used
public static GridBlock[] assignGridOrdering(int[] grid_dimensions, int[] inactive_blocks, NumberingScheme scheme)
{
//variables to store the grid dimensions
int x, y, z;
//store the grid dimensions
x = grid_dimensions[0]; y = grid_dimensions[1]; z = grid_dimensions[2];
//an array to store a block's i, j and k coordinates within the grid according to the engineering notation
int[] block_coordinates = new int[3];
//A variable to store block's data
GridBlock block;
//A variable representing the grid array of blocks
GridBlock[] grid = new GridBlock[0];
if (scheme == NumberingScheme.All)
{
//Grid array size is equal to all the block "including in-active blocks"
grid = new GridBlock[x * y * z];
}
else if (scheme == NumberingScheme.Active_Only)
{
//Grid array size is equal to the number of active-only blocks
grid = new GridBlock[x * y * z - inactive_blocks.Length];
}
//A general loop counter
int counter = 0;
//A block counter
//This variable is used only with the "assignBlockOrdering_ActiveOnly" method to keep track of the number of active blocks added to the grid
int block_counter = 0;
//A loop to iterate over all the blocks in the grid according to the engineering notation
for (int k = 0; k < z; k++)
{
for (int j = 0; j < y; j++)
{
for (int i = 0; i < x; i++)
{
block = new GridBlock();
//assign the values of the block coordinates
block.x = i; block.y = j; block.z = k;
//set block type "either Inactive or normal"
if (inactive_blocks.Contains(counter))
{
block.type = GridBlock.Type.Inactive;
}
//set the block coordinates array that will be passed to other methods
block_coordinates[0] = i; block_coordinates[1] = j; block_coordinates[2] = k;
//###########################################################################################
if (scheme == NumberingScheme.All)
{
//Natural ordering for the entire grid "both active and in-active blocks"
RectangularBlockNumbering.assignBlockOrdering_Natural(block, counter, block_coordinates, grid_dimensions, inactive_blocks);
}
else if (scheme == NumberingScheme.Active_Only)
{
//Natural ordering for the grid "active blocks only"
if (block.type == GridBlock.Type.Inactive)
{
//increment the general loop counter and skip this block
counter += 1;
continue;
}
RectangularBlockNumbering.assignBlockOrdering_ActiveOnly(block, counter, block_counter, block_coordinates, grid_dimensions, inactive_blocks);
}
//###########################################################################################
//increment counter at the end of the loop
counter += 1;
//this statement adds the block to the grid array
grid[block_counter] = block;
//only increment block_counter when a block is added to the grid to keep track of how many blocks have been added
block_counter += 1;
}
}
}
return(grid);
}