public async Task Initialize()
{
try
{
await _semaphore.WaitAsync();
if (!_initialized)
{
_gpioController.OpenPin(_configurationService.SaunaOutputGpioPin, PinMode.Output);
_gpioController.Write(_configurationService.SaunaOutputGpioPin, PinValue.High);
_gpioController.OpenPin(_configurationService.InfraredOutputGpioPin, PinMode.Output);
_gpioController.Write(_configurationService.InfraredOutputGpioPin, PinValue.High);
_gpioController.OpenPin(_configurationService.SaunaInputGpioPin, PinMode.Input);
_gpioController.OpenPin(_configurationService.InfraredInputGpioPin, PinMode.Input);
_initialized = true;
}
}
finally
{
_semaphore.Release();
}
}
private void InitializeRelayDevice(RelayDevice device)
{
controller.OpenPin(device.GpioId);
controller.SetPinMode(device.GpioId, PinMode.Output);
// Relay needs high
controller.Write(device.GpioId, PinValue.High);
// Store in map for quick access
deviceMap.Add(device.Id, device);
}
private void Initialise(byte trig_Pin, byte echo_Pin, int timeoutMilliseconds)
{
_trig_Pin = trig_Pin;
_echo_Pin = echo_Pin;
TimeoutMilliseconds = timeoutMilliseconds;
_gpio.OpenPin(trig_Pin, PinMode.Output);
_gpio.OpenPin(echo_Pin, PinMode.Input);
_gpio.Write(trig_Pin, PinValue.Low);
}
public Motor(IGpioController gpio, byte in1, byte in2)
{
_gpio = gpio;
_in1 = in1;
_in2 = in2;
_gpio.OpenPin(in1, PinMode.Output);
_gpio.OpenPin(in2, PinMode.Output);
_gpio.Write(in1, PinValue.Low);
_gpio.Write(in2, PinValue.Low);
}
public SpiInterface(SpiDevice device, IGpioController controller, int dcPin, int rstPin)
{
_device = device ?? throw new ArgumentNullException(nameof(device));
_controller = controller ?? throw new ArgumentNullException(nameof(controller));
_dcPin = dcPin;
_rstPin = rstPin;
_disposables.Add(_controller.OpenPin(_dcPin, PinMode.Output));
_disposables.Add(_controller.OpenPin(_rstPin, PinMode.Output));
_controller.Write(_rstPin, PinValue.Low);
_controller.Write(_rstPin, PinValue.High);
}
/// <summary>
/// Disables the device by setting the reset pin low.
/// </summary>
public void Disable()
{
if (_reset == -1)
{
throw new InvalidOperationException("No reset pin configured.");
}
_masterGpioController.Write(_reset, PinValue.Low);
// Registers will all be reset when re-enabled
_bankStyle = BankStyle.Sequential;
_increments = true;
_disabled = true;
}
/// <summary>
/// Stop the motor.
/// </summary>
public void Stop()
{
_steps = 0;
_stopwatch?.Stop();
_controller.Write(_pin1, PinValue.Low);
_controller.Write(_pin2, PinValue.Low);
_controller.Write(_pin3, PinValue.Low);
_controller.Write(_pin4, PinValue.Low);
}
/// <summary>
/// Initializes the bit mode settings.
/// </summary>
protected override void InitializeBitMode()
{
// Prep the pins
_controller.OpenPin(_rsPin, PinMode.Output);
if (_rwPin != -1)
{
_controller.OpenPin(_rwPin, PinMode.Output);
}
if (_backlight != -1)
{
_controller.OpenPin(_backlight, PinMode.Output);
if (_backlightBrightness > 0)
{
// Turn on the backlight
_controller.Write(_backlight, PinValue.High);
}
}
_controller.OpenPin(_enablePin, PinMode.Output);
for (int i = 0; i < _dataPins.Length; ++i)
{
_controller.OpenPin(_dataPins[i], PinMode.Output);
}
// The HD44780 self-initializes when power is turned on to the following settings:
//
// - 8 bit, 1 line, 5x7 font
// - Display, cursor, and blink off
// - Increment with no shift
//
// It is possible that the initialization will fail if the power is not provided
// within specific tolerances. As such, we'll always perform the software based
// initialization as described on pages 45/46 of the HD44780 data sheet. We give
// a little extra time to the required waits.
if (_dataPins.Length == 8)
{
// Init to 8 bit mode
DelayMicroseconds(50_000, checkBusy: false);
Send(0b0011_0000);
DelayMicroseconds(5_000, checkBusy: false);
Send(0b0011_0000);
DelayMicroseconds(100, checkBusy: false);
Send(0b0011_0000);
}
else
{
// Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly.
// (Send writes the whole byte in two 4bit/nybble chunks)
_controller.Write(_rsPin, PinValue.Low);
DelayMicroseconds(50_000, checkBusy: false);
WriteBits(0b0011, 4);
DelayMicroseconds(5_000, checkBusy: false);
WriteBits(0b0011, 4);
DelayMicroseconds(100, checkBusy: false);
WriteBits(0b0011, 4);
WriteBits(0b0010, 4);
}
}
private void InitLed(int pinNumber)
{
_ts.pinNumber = pinNumber;
_gpio.OpenPin(_ts.pinNumber, PinMode.Output);
_gpio.Write(_ts.pinNumber, PinValue.Low);
_ts.tmr = new Timer(BlinkTime_Tick, _ts, Timeout.Infinite, Timeout.Infinite);
}
public void Command(params byte[] cmds)
{
_controller.Write(_dcPin, PinValue.Low); // Command Mode
_device.Write(cmds);
}
public void Write(int pinNumber, PinValue value)
{
_controller.Write(pinNumber, value);
}
/// <summary>
/// Initializes the display by setting the specified columns and lines.
/// </summary>
private void Initialize(int rows)
{
// While the chip supports 5x10 pixel characters for one line displays they
// don't seem to be generally available. Supporting 5x10 would require extra
// support for CreateCustomCharacter
if (SetTwoLineMode(rows))
{
_displayFunction |= DisplayFunction.TwoLine;
}
_displayControl |= DisplayControl.DisplayOn;
_displayMode |= DisplayEntryMode.Increment;
// Prep the pins
_controller.OpenPin(_rsPin, PinMode.Output);
if (_rwPin != -1)
{
_controller.OpenPin(_rwPin, PinMode.Output);
}
if (_backlight != -1)
{
_controller.OpenPin(_backlight, PinMode.Output);
if (_backlightBrightness > 0)
{
// Turn on the backlight
_controller.Write(_backlight, PinValue.High);
}
}
_controller.OpenPin(_enablePin, PinMode.Output);
for (int i = 0; i < _dataPins.Length; ++i)
{
_controller.OpenPin(_dataPins[i], PinMode.Output);
}
// The HD44780 self-initializes when power is turned on to the following settings:
//
// - 8 bit, 1 line, 5x7 font
// - Display, cursor, and blink off
// - Increment with no shift
//
// It is possible that the initialization will fail if the power is not provided
// within specific tolerances. As such, we'll always perform the software based
// initialization as described on pages 45/46 of the HD44780 data sheet. We give
// a little extra time to the required waits.
if (_dataPins.Length == 8)
{
// Init to 8 bit mode
DelayMicroseconds(50_000, checkBusy: false);
Send(0b0011_0000);
DelayMicroseconds(5_000, checkBusy: false);
Send(0b0011_0000);
DelayMicroseconds(100, checkBusy: false);
Send(0b0011_0000);
}
else
{
// Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly.
// (Send writes the whole byte in two 4bit/nybble chunks)
_controller.Write(_rsPin, PinValue.Low);
DelayMicroseconds(50_000, checkBusy: false);
WriteBits(0b0011, 4);
DelayMicroseconds(5_000, checkBusy: false);
WriteBits(0b0011, 4);
DelayMicroseconds(100, checkBusy: false);
WriteBits(0b0011, 4);
WriteBits(0b0010, 4);
}
// The busy flag cannot be checked until this point.
Send((byte)_displayFunction);
Send((byte)_displayControl);
Send((byte)_displayMode);
Clear();
}
public void Forward()
{
_gpio.Write(_in1, PinValue.Low);
_gpio.Write(_in2, PinValue.High);
}
private void WriteToServo(int servoPin, PinValue pinValue)
{
_logger.LogTrace($"Writing {pinValue} to pin {servoPin}");
_gpioController.Write(servoPin, PinValue.Low);
_logger.LogTrace($"Wrote {pinValue} to pin {servoPin}");
}
private void Initialize()
{
// Prep the pins
_controller.OpenPin(_rsPin, PinMode.Output);
if (_rwPin != -1)
{
_controller.OpenPin(_rwPin, PinMode.Output);
// Set to write. Once we enable reading have reading pull high and reset
// after reading to give maximum performance to write (i.e. assume that
// the pin is low when writing).
_controller.Write(_rwPin, PinValue.Low);
}
if (_backlight != -1)
{
_controller.OpenPin(_backlight, PinMode.Output);
if (_backlightBrightness > 0)
{
// Turn on the backlight
_controller.Write(_backlight, PinValue.High);
}
}
_controller.OpenPin(_enablePin, PinMode.Output);
for (int i = 0; i < _dataPins.Length; ++i)
{
_controller.OpenPin(_dataPins[i], PinMode.Output);
}
// The HD44780 self-initializes when power is turned on to the following settings:
//
// - 8 bit, 1 line, 5x7 font
// - Display, cursor, and blink off
// - Increment with no shift
//
// It is possible that the initialization will fail if the power is not provided
// within specific tolerances. As such, we'll always perform the software based
// initialization as described on pages 45/46 of the HD44780 data sheet. We give
// a little extra time to the required waits as described.
if (_dataPins.Length == 8)
{
// Init to 8 bit mode (this is the default, but other drivers
// may set the controller to 4 bit mode, so reset to be safe.)
DelayHelper.DelayMilliseconds(50, allowThreadYield: true);
WriteBits(0b0011_0000, 8);
DelayHelper.DelayMilliseconds(5, allowThreadYield: true);
WriteBits(0b0011_0000, 8);
DelayHelper.DelayMicroseconds(100, allowThreadYield: true);
WriteBits(0b0011_0000, 8);
}
else
{
// Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly.
// (Send writes the whole byte in two 4bit/nybble chunks)
_controller.Write(_rsPin, PinValue.Low);
DelayHelper.DelayMilliseconds(50, allowThreadYield: true);
WriteBits(0b0011, 4);
DelayHelper.DelayMilliseconds(5, allowThreadYield: true);
WriteBits(0b0011, 4);
DelayHelper.DelayMicroseconds(100, allowThreadYield: true);
WriteBits(0b0011, 4);
WriteBits(0b0010, 4);
}
// The busy flag can NOT be checked until this point.
}