public string getDado()
{
string IdBinario;
int bits = 0;
char[] s = new char[maxBits];
while (true)
{
if (controller.Read(pino0) == PinValue.Low)
{
s[bits++] = '0';
while (controller.Read(pino0) == PinValue.Low)
{
}
}
if (controller.Read(pino1) == PinValue.Low)
{
s[bits++] = '1';
while (controller.Read(pino1) == PinValue.Low)
{
}
}
if (bits == maxBits)
{
IdBinario = getBinario(s);
break;
}
}
//Print(IdBinario);
return(getId(IdBinario));
}
public bool ReadDistance()
{
_controller.Write(Trigger, PinValue.Low);
Thread.Sleep(5);
_controller.Write(Trigger, PinValue.High);
Thread.Sleep(10);
_controller.Write(Trigger, PinValue.Low);
DateTime timeout = DateTime.Now.AddMilliseconds(Timeout);
while (_controller.Read(Echo) == PinValue.Low)
{
if (DateTime.Now > timeout)
{
return(false);
}
}
long startTicks = DateTime.Now.Ticks;
timeout = DateTime.Now.AddMilliseconds(Timeout);
while (_controller.Read(Echo) == PinValue.High)
{
if (DateTime.Now > timeout)
{
return(false);
}
}
long endTicks = DateTime.Now.Ticks;
_distance = (endTicks - startTicks) * 34.32 / (2 * TimeSpan.TicksPerMillisecond);
_milliseconds = (double)(endTicks - startTicks) / TimeSpan.TicksPerMillisecond;
return(true);
}
static void Main(string[] args)
{
var lightPin = 23;
var controller = new GpioController();
controller.OpenPin(lightPin, PinMode.Input);
var state = controller.Read(lightPin);
while (true)
{
if (state == controller.Read(lightPin))
{
if (controller.Read(lightPin) == PinValue.High)
{
Console.WriteLine("\u263e");
}
else
{
Console.WriteLine("\u263c");
}
}
state = controller.Read(lightPin);
Thread.Sleep(200);
}
}
private List <HJIR2ReadEventArgs> RetrieveSensorData()
{
List <HJIR2ReadEventArgs> list = new List <HJIR2ReadEventArgs>();
try
{
if (_controller.Read(_left) == PinValue.Low)
{
list.Add(new HJIR2ReadEventArgs(true)
{
type = 1, HasObstacles = true
});
}
if (_controller.Read(_right) == PinValue.Low)
{
list.Add(new HJIR2ReadEventArgs(true)
{
type = 2, HasObstacles = true
});
}
return(list);
}
catch
{
list.Add(HJIR2ReadEventArgs.CreateInvalidReading());
return(list);
}
}
private void ReadPins()
{
while (true)
{
Console.WriteLine($"Blue : {controller.Read(20)}, Yellow: {controller.Read(21)}");
Thread.Sleep(1000);
}
}
private bool ReadBit()
{
_controller.Write(_settings.SCKPin, PinValue.High);
_controller.Write(_settings.SCKPin, PinValue.Low);
var pin = _controller.Read(_settings.DTPin);
return(pin == PinValue.High ? true : false);
}
static void Main(string[] args)
{
// Set debounce delay to 5ms
int debounceDelay = 50000;
int pin = 7;
Console.WriteLine($"Let's blink an on-board LED!");
using GpioController controller = new GpioController(PinNumberingScheme.Board, new OrangePi4Driver());
using BoardLed led = new BoardLed("status_led");
controller.OpenPin(pin, PinMode.InputPullUp);
led.Trigger = "none";
Console.WriteLine($"GPIO pin enabled for use: {pin}.");
Console.WriteLine("Press any key to exit.");
while (!Console.KeyAvailable)
{
if (Debounce())
{
// Button is pressed
led.Brightness = 1;
}
else
{
// Button is unpressed
led.Brightness = 0;
}
}
bool Debounce()
{
long debounceTick = DateTime.Now.Ticks;
PinValue buttonState = controller.Read(pin);
do
{
PinValue currentState = controller.Read(pin);
if (currentState != buttonState)
{
debounceTick = DateTime.Now.Ticks;
buttonState = currentState;
}
}while (DateTime.Now.Ticks - debounceTick < debounceDelay);
if (buttonState == PinValue.Low)
{
return(true);
}
else
{
return(false);
}
}
}
/// <summary>
/// Read from the sensor
/// </summary>
/// <returns>If a motion is detected, return true.</returns>
public bool Read()
{
if (_controller.Read(_pinOut) == PinValue.High)
{
return(true);
}
else
{
return(false);
}
}
static void Main(string[] args)
{
var iMapping = new int[] { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
var oMapping = new int[] { 17, 18, 22, 23, 24, 25, 26, 27, };
int inputPinCount = iMapping.Length;
int outputPinCount = oMapping.Length;
var gpio = new GpioController();
// define pin mode
for (int i = 0; i < inputPinCount; ++i)
{
gpio.OpenPin(iMapping[i], PinMode.Input);
}
for (int i = 0; i < outputPinCount; ++i)
{
gpio.OpenPin(oMapping[i], PinMode.Output);
}
// warm up
for (int i = 0; i < inputPinCount; ++i)
{
gpio.Read(iMapping[i]);
}
var stopWatch = Stopwatch.StartNew();
int cycleCounter = 0;
// Loop for 10 seconds
while (stopWatch.Elapsed.TotalSeconds < 10)
{
for (int i = 0; i < inputPinCount; ++i)
{
gpio.Read(iMapping[i]);
}
for (int i = 0; i < outputPinCount; ++i)
{
gpio.Write(oMapping[i], PinValue.High);
}
for (int i = 0; i < outputPinCount; ++i)
{
gpio.Write(oMapping[i], PinValue.Low);
}
++cycleCounter;
}
Console.WriteLine("Read/Write frequency for " + inputPinCount + " inputs and "
+ outputPinCount + " outputs : "
+ (cycleCounter / stopWatch.Elapsed.TotalSeconds).ToString("N", CultureInfo.InvariantCulture)
+ "Hz");;
Console.WriteLine("Running for : " + stopWatch.Elapsed.TotalSeconds + " seconds.");
}
public void Start()
{
using (GpioController gpio = new GpioController(PinNumberingScheme.Logical, new RaspberryPi3Driver()))
for (int x = 0; x < 50; x++)
{
{
gpio.OpenPin(TRIG, PinMode.Output);
gpio.Write(TRIG, 0);
gpio.OpenPin(ECHO, PinMode.Input);
Thread.Sleep(TimeSpan.FromSeconds(0.1));
var startScanning = DateTime.Now.AddSeconds(2);
gpio.Write(TRIG, 1);
Thread.Sleep(TimeSpan.FromSeconds(0.1));
Boolean worked = true;
gpio.Write(TRIG, 0);
while (gpio.Read(ECHO) == 0)
{
if (DateTime.Now > startScanning)
{
Console.WriteLine("Failed aftre 2 sec");
gpio.ClosePin(ECHO);
gpio.ClosePin(TRIG);
worked = false;
break;
}
}
if (worked)
{
var start = DateTime.Now;
while (gpio.Read(ECHO) == 1)
{
}
var stop = DateTime.Now;
//Console.WriteLine(stop.Ticks);
distance = ((stop.Ticks - start.Ticks) * 17) / 10000;
Console.WriteLine(distance);
gpio.ClosePin(ECHO);
gpio.ClosePin(TRIG);
}
}
}
}
public void StartSonic()
{
Console.WriteLine("Start Sonic");
for (int x = 0; x < 1000; x++)
{
gpio.OpenPin(TRIG, PinMode.Output);
gpio.Write(TRIG, 0);
gpio.OpenPin(ECHO, PinMode.Input);
Thread.Sleep(TimeSpan.FromSeconds(0.1));
var startScanning = DateTime.Now.AddSeconds(2);
gpio.Write(TRIG, 1);
Thread.Sleep(TimeSpan.FromSeconds(0.1));
Boolean worked = true;
gpio.Write(TRIG, 0);
while (gpio.Read(ECHO) == 0)
{
if (DateTime.Now > startScanning)
{
Console.WriteLine("Failed aftre 2 sec");
gpio.ClosePin(ECHO);
gpio.ClosePin(TRIG);
worked = false;
break;
}
}
if (worked)
{
var start = DateTime.Now;
while (gpio.Read(ECHO) == 1)
{
}
var stop = DateTime.Now;
//Console.WriteLine(stop.Ticks);
distance = ((stop.Ticks - start.Ticks) * 17) / 10000;
Console.WriteLine(distance);
gpio.ClosePin(ECHO);
gpio.ClosePin(TRIG);
}
}
EndAll();
}
private void setupGpio()
{
_logger.LogDebug($"Setting-Up Gpio's...");
if (!_gpioController.IsPinOpen(_gpioSettings.PowerPin))
{
_gpioController.OpenPin(_gpioSettings.PowerPin, PinMode.Output);
}
if (!_gpioController.IsPinOpen(_gpioSettings.ValvePin))
{
_gpioController.OpenPin(_gpioSettings.ValvePin, PinMode.Output);
}
if (!_gpioController.IsPinOpen(_gpioSettings.PumpPin))
{
_gpioController.OpenPin(_gpioSettings.PumpPin, PinMode.Output);
}
if (!_gpioController.IsPinOpen(_gpioSettings.WaterLevelPin))
{
_logger.LogDebug($"Opening Waterlevel pin {_gpioSettings.WaterLevelPin}...");
_gpioController.OpenPin(_gpioSettings.WaterLevelPin);
_logger.LogDebug("Waterlevel pin is open! Set mode to input...");
_gpioController.SetPinMode(_gpioSettings.WaterLevelPin, PinMode.InputPullDown);
_logger.LogDebug("Waterlevel pin mode is input! Reading value...");
//_gpioController.OpenPin(_gpioSettings.WaterLevelPin, PinMode.InputPullDown);
var val = _gpioController.Read(_gpioSettings.WaterLevelPin);
_logger.LogDebug($"Waterlevel value is {val}!");
Task.Run(async() =>
{
await _appState.GpioValueChangedAsync(
new ToggleChangedModel
{
ToggleType = ToggleType.WATERLEVEL,
NewValue = val == PinValue.High ? true : false
});
});
}
if (!_gpioController.IsPinOpen(_gpioSettings.WerferPin))
{
_gpioController.OpenPin(_gpioSettings.WerferPin, PinMode.Output);
}
if (!_gpioController.IsPinOpen(_gpioSettings.SprueherPin))
{
_gpioController.OpenPin(_gpioSettings.SprueherPin, PinMode.Output);
}
if (!_gpioController.IsPinOpen(_gpioSettings.TropferPin))
{
_gpioController.OpenPin(_gpioSettings.TropferPin, PinMode.Output);
}
_logger.LogDebug($"Gpio setup finished!");
}