public Task<SetupGpIoResponse> GpIoSetup(PinName pin, GpioDirection direction)
{
RestRequest restRequest = GetRestRequest(ApiPaths.SetupGpIo, Method.GET);
restRequest.AddUrlSegment("pin", pin.ToString());
restRequest.AddUrlSegment("direction", direction.ToString());
return ProcessDefaultRequest<SetupGpIoResponse>(restRequest);
}
public void SetDirection(string hostId, int gpioId, GpioDirection direction)
{
if (hostId == null)
{
throw new ArgumentNullException(nameof(hostId));
}
GetAdapter(hostId).SetDirection(gpioId, direction);
}
public void SetDirection(GpioDirection direction)
{
// Edge is only required if the state is read via blocked thread.
//File.WriteAllText("/sys/class/gpio/gpio" + gpioId + "/edge", edge.ToString().ToLowerInvariant());
var fileContent = direction == GpioDirection.Output ? "out" : "in";
File.WriteAllText(_directionPath, fileContent, Encoding.ASCII);
}
public void SetDirection(int gpioId, GpioDirection direction)
{
lock (_syncRoot)
{
Export(gpioId);
var fileContent = direction == GpioDirection.Output ? "out" : "in";
File.WriteAllText("/sys/class/gpio/gpio" + gpioId + "/direction", fileContent, Encoding.ASCII);
}
}
/// <summary>
/// Creates a pin if it has not already been created (exported), creates a GPIOMem if possible, otherwise falls back to GPIOFile.
/// </summary>
/// <param name="pin">The pin to create or export</param>
/// <param name="dir">The direction the pin is to have</param>
/// <returns>The GPIO instance representing the pin</returns>
public static GpioFile CreatePinFile(GpioPins pin, GpioDirection dir)
{
try {
return(new GpioFile(pin, dir, false));
}
catch (Exception e) {
System.Diagnostics.Debug.WriteLine("Unable to create pin " + (uint)pin + " as GPIOFile because: " + e.ToString());
}
return(null);
}
/// <summary>
/// 指定したgpioピンにデータ設定方向を設定します。
/// </summary>
/// <param name="gpio"></param>
/// <param name="direction"></param>
public static void SetDirection(int gpio, GpioDirection direction)
{
if (direction == GpioDirection.In)
{
File.WriteAllText($"/sys/class/gpio/gpio{gpio}/direction", "in");
}
else
{
File.WriteAllText($"/sys/class/gpio/gpio{gpio}/direction", "out");
}
}
private void SetDirection(GpioDirection gpioDirection)
{
ExportPinIfRequired();
if (_direction == gpioDirection)
{
return;
}
_fileIo.WriteAllText(_directionPinPath, gpioDirection.ToString().ToLowerInvariant());
_direction = gpioDirection;
}
public void SetDirection(int gpioId, GpioDirection direction)
{
lock (_syncRoot)
{
ExportGpio(gpioId);
var fileContent = direction == GpioDirection.Output ? "out" : "in";
WriteGpioDirection(gpioId, fileContent);
_logger.Log(LogLevel.Information, $"Exported GPIO {gpioId}.");
}
}
public async Task SetDirection(string pin, GpioDirection direction)
{
string direct;
switch (direction)
{
case GpioDirection.In:
direct = "in";
break;
case GpioDirection.Out:
direct = "out";
break;
case GpioDirection.Low:
direct = "low";
break;
case GpioDirection.High:
direct = "high";
break;
default:
throw new ArgumentException("Requires a direction");
}
try
{
using (var writer = new StreamWriter(GpioPath.DirectionPath(pin), false))
{
await writer.WriteAsync(direct);
return;
}
}
catch (UnauthorizedAccessException)
{
// User is not root and the permissions have not been set yet. Need to wait.
Thread.Sleep(TimeSpan.FromSeconds(0.5));
}
using (var writer = new StreamWriter(GpioPath.DirectionPath(pin), false))
{
await writer.WriteAsync(direct);
}
}
public DummyGpioPin(
string name,
GpioDirection?direction,
bool?activeLow,
bool?initialValue,
TimeSpan?assertionTime,
TimeSpan?deassertionTime,
TimeSpan?debounceTime)
{
this.Name = name;
this.direction = direction ?? GpioDirection.Input;
this.value = initialValue ?? false;
this.AssertionTime = assertionTime ?? defaultAssertionTime;
this.DeassertionTime = deassertionTime ?? defaultDeassertionTime;
this.DebounceTime = debounceTime ?? defaultDebounceTime;
this.pinChangeEvent = new AsyncAutoResetEvent();
this.isDisposed = false;
}
public GpioFile(GpioPins pin, GpioDirection direction, bool initialValue)
{
if (pin == GpioPins.GpioNone)
{
throw new ArgumentException("Invalid pin");
}
gpio_open();
_pin = pin;
try {
PinDirection = direction;
Write(initialValue);
}
catch {
Dispose();
throw;
}
}
public static string ToDirectionString(this GpioDirection direction, bool?initialLevel = null)
{
switch (direction)
{
case GpioDirection.Input:
return("in");
case GpioDirection.Output:
if (initialLevel.HasValue)
{
return(initialLevel.Value ? "high" : "low");
}
else
{
return("out");
}
default:
throw new InvalidOperationException("Invalid direction value");
}
}
public async Task SetDirection(string pin, GpioDirection direction)
{
string direct;
switch (direction)
{
case GpioDirection.In:
direct = "in";
break;
case GpioDirection.Out:
direct = "out";
break;
case GpioDirection.Low:
direct = "low";
break;
case GpioDirection.High:
direct = "high";
break;
default:
throw new ArgumentException("Requires a direction");
}
try
{
using (var writer = new StreamWriter(GpioPath.DirectionPath(pin), false))
{
await writer.WriteAsync(direct);
return;
}
}
catch (UnauthorizedAccessException)
{
// User is not root and the permissions have not been set yet. Need to wait.
Thread.Sleep(TimeSpan.FromSeconds(0.5));
}
using (var writer = new StreamWriter(GpioPath.DirectionPath(pin), false))
{
await writer.WriteAsync(direct);
}
}
private async Task SetDirection(GpioDirection direction)
{
await _driver.SetDirection(_pin, direction);
}
public void SetDirection(int gpio, GpioDirection direction)
{
//_logger.Log(LogLevel.Information, $"FAKE SetDirection: GPIO = {gpio}; Direction = {direction}");
}
