diff --git a/Unosquare.WiringPi/BootstrapWiringPi.cs b/Unosquare.WiringPi/BootstrapWiringPi.cs
index 6c70067..3ac6d24 100644
--- a/Unosquare.WiringPi/BootstrapWiringPi.cs
+++ b/Unosquare.WiringPi/BootstrapWiringPi.cs
@@ -1,15 +1,17 @@
-namespace Unosquare.WiringPi
-{
- using RaspberryIO.Abstractions;
- using Swan.DependencyInjection;
-
- ///
- /// Represents the Bootstrap class to extract resources.
- ///
- ///
- public class BootstrapWiringPi : IBootstrap
+using System;
+
+using Swan.DependencyInjection;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Represents the Bootstrap class to extract resources.
+ ///
+ ///
+ public class BootstrapWiringPi : IBootstrap
{
- private static readonly object SyncLock = new object();
+ private static readonly Object SyncLock = new Object();
///
public void Bootstrap()
diff --git a/Unosquare.WiringPi/Enums.cs b/Unosquare.WiringPi/Enums.cs
index 5e5c6b3..2d51e11 100644
--- a/Unosquare.WiringPi/Enums.cs
+++ b/Unosquare.WiringPi/Enums.cs
@@ -1,289 +1,284 @@
-namespace Unosquare.WiringPi
-{
- using System;
-
+using System;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Defines all the available Wiring Pi Pin Numbers.
+ ///
+ public enum WiringPiPin {
///
- /// Defines all the available Wiring Pi Pin Numbers.
+ /// Unknown WiringPi pin.
///
- public enum WiringPiPin
- {
- ///
- /// Unknown WiringPi pin.
- ///
- Unknown = -1,
-
- ///
- /// WiringPi pin 0.
- ///
- Pin00 = 0,
-
- ///
- /// WiringPi pin 1.
- ///
- Pin01 = 1,
-
- ///
- /// WiringPi pin 2.
- ///
- Pin02 = 2,
-
- ///
- /// WiringPi pin 3.
- ///
- Pin03 = 3,
-
- ///
- /// WiringPi pin 4.
- ///
- Pin04 = 4,
-
- ///
- /// WiringPi pin 5.
- ///
- Pin05 = 5,
-
- ///
- /// WiringPi pin 6.
- ///
- Pin06 = 6,
-
- ///
- /// WiringPi pin 7.
- ///
- Pin07 = 7,
-
- ///
- /// WiringPi pin 8.
- ///
- Pin08 = 8,
-
- ///
- /// WiringPi pin 9.
- ///
- Pin09 = 9,
-
- ///
- /// WiringPi pin 10.
- ///
- Pin10 = 10,
-
- ///
- /// WiringPi pin 11.
- ///
- Pin11 = 11,
-
- ///
- /// WiringPi pin 12.
- ///
- Pin12 = 12,
-
- ///
- /// WiringPi pin 13.
- ///
- Pin13 = 13,
-
- ///
- /// WiringPi pin 14.
- ///
- Pin14 = 14,
-
- ///
- /// WiringPi pin 15.
- ///
- Pin15 = 15,
-
- ///
- /// WiringPi pin 16.
- ///
- Pin16 = 16,
-
- ///
- /// WiringPi pin 17.
- ///
- Pin17 = 17,
-
- ///
- /// WiringPi pin 18.
- ///
- Pin18 = 18,
-
- ///
- /// WiringPi pin 19.
- ///
- Pin19 = 19,
-
- ///
- /// WiringPi pin 20.
- ///
- Pin20 = 20,
-
- ///
- /// WiringPi pin 21.
- ///
- Pin21 = 21,
-
- ///
- /// WiringPi pin 22.
- ///
- Pin22 = 22,
-
- ///
- /// WiringPi pin 23.
- ///
- Pin23 = 23,
-
- ///
- /// WiringPi pin 24.
- ///
- Pin24 = 24,
-
- ///
- /// WiringPi pin 25.
- ///
- Pin25 = 25,
-
- ///
- /// WiringPi pin 26.
- ///
- Pin26 = 26,
-
- ///
- /// WiringPi pin 27.
- ///
- Pin27 = 27,
-
- ///
- /// WiringPi pin 28.
- ///
- Pin28 = 28,
-
- ///
- /// WiringPi pin 29.
- ///
- Pin29 = 29,
-
- ///
- /// WiringPi pin 30.
- ///
- Pin30 = 30,
-
- ///
- /// WiringPi pin 31.
- ///
- Pin31 = 31,
- }
-
+ Unknown = -1,
+
///
- /// Defines the different pin capabilities.
+ /// WiringPi pin 0.
///
- [Flags]
- public enum PinCapability
- {
- ///
- /// General Purpose capability: Digital and Analog Read/Write
- ///
- GP = 0x01,
-
- ///
- /// General Purpose Clock (not PWM)
- ///
- GPCLK = 0x02,
-
- ///
- /// i2c data channel
- ///
- I2CSDA = 0x04,
-
- ///
- /// i2c clock channel
- ///
- I2CSCL = 0x08,
-
- ///
- /// SPI Master Out, Slave In channel
- ///
- SPIMOSI = 0x10,
-
- ///
- /// SPI Master In, Slave Out channel
- ///
- SPIMISO = 0x20,
-
- ///
- /// SPI Clock channel
- ///
- SPICLK = 0x40,
-
- ///
- /// SPI Chip Select Channel
- ///
- SPICS = 0x80,
-
- ///
- /// UART Request to Send Channel
- ///
- UARTRTS = 0x100,
-
- ///
- /// UART Transmit Channel
- ///
- UARTTXD = 0x200,
-
- ///
- /// UART Receive Channel
- ///
- UARTRXD = 0x400,
-
- ///
- /// Hardware Pule Width Modulation
- ///
- PWM = 0x800,
- }
-
+ Pin00 = 0,
+
///
- /// The PWM mode.
+ /// WiringPi pin 1.
///
- public enum PwmMode
- {
- ///
- /// PWM pulses are sent using mark-sign patterns (old school)
- ///
- MarkSign = 0,
-
- ///
- /// PWM pulses are sent as a balanced signal (default, newer mode)
- ///
- Balanced = 1,
- }
-
+ Pin01 = 1,
+
///
- /// Defines GPIO controller initialization modes.
+ /// WiringPi pin 2.
///
- internal enum ControllerMode
- {
- ///
- /// The not initialized
- ///
- NotInitialized,
-
- ///
- /// The direct with wiring pi pins
- ///
- DirectWithWiringPiPins,
-
- ///
- /// The direct with BCM pins
- ///
- DirectWithBcmPins,
-
- ///
- /// The direct with header pins
- ///
- DirectWithHeaderPins,
-
- ///
- /// The file stream with hardware pins
- ///
- FileStreamWithHardwarePins,
- }
+ Pin02 = 2,
+
+ ///
+ /// WiringPi pin 3.
+ ///
+ Pin03 = 3,
+
+ ///
+ /// WiringPi pin 4.
+ ///
+ Pin04 = 4,
+
+ ///
+ /// WiringPi pin 5.
+ ///
+ Pin05 = 5,
+
+ ///
+ /// WiringPi pin 6.
+ ///
+ Pin06 = 6,
+
+ ///
+ /// WiringPi pin 7.
+ ///
+ Pin07 = 7,
+
+ ///
+ /// WiringPi pin 8.
+ ///
+ Pin08 = 8,
+
+ ///
+ /// WiringPi pin 9.
+ ///
+ Pin09 = 9,
+
+ ///
+ /// WiringPi pin 10.
+ ///
+ Pin10 = 10,
+
+ ///
+ /// WiringPi pin 11.
+ ///
+ Pin11 = 11,
+
+ ///
+ /// WiringPi pin 12.
+ ///
+ Pin12 = 12,
+
+ ///
+ /// WiringPi pin 13.
+ ///
+ Pin13 = 13,
+
+ ///
+ /// WiringPi pin 14.
+ ///
+ Pin14 = 14,
+
+ ///
+ /// WiringPi pin 15.
+ ///
+ Pin15 = 15,
+
+ ///
+ /// WiringPi pin 16.
+ ///
+ Pin16 = 16,
+
+ ///
+ /// WiringPi pin 17.
+ ///
+ Pin17 = 17,
+
+ ///
+ /// WiringPi pin 18.
+ ///
+ Pin18 = 18,
+
+ ///
+ /// WiringPi pin 19.
+ ///
+ Pin19 = 19,
+
+ ///
+ /// WiringPi pin 20.
+ ///
+ Pin20 = 20,
+
+ ///
+ /// WiringPi pin 21.
+ ///
+ Pin21 = 21,
+
+ ///
+ /// WiringPi pin 22.
+ ///
+ Pin22 = 22,
+
+ ///
+ /// WiringPi pin 23.
+ ///
+ Pin23 = 23,
+
+ ///
+ /// WiringPi pin 24.
+ ///
+ Pin24 = 24,
+
+ ///
+ /// WiringPi pin 25.
+ ///
+ Pin25 = 25,
+
+ ///
+ /// WiringPi pin 26.
+ ///
+ Pin26 = 26,
+
+ ///
+ /// WiringPi pin 27.
+ ///
+ Pin27 = 27,
+
+ ///
+ /// WiringPi pin 28.
+ ///
+ Pin28 = 28,
+
+ ///
+ /// WiringPi pin 29.
+ ///
+ Pin29 = 29,
+
+ ///
+ /// WiringPi pin 30.
+ ///
+ Pin30 = 30,
+
+ ///
+ /// WiringPi pin 31.
+ ///
+ Pin31 = 31,
+ }
+
+ ///
+ /// Defines the different pin capabilities.
+ ///
+ [Flags]
+ public enum PinCapability {
+ ///
+ /// General Purpose capability: Digital and Analog Read/Write
+ ///
+ GP = 0x01,
+
+ ///
+ /// General Purpose Clock (not PWM)
+ ///
+ GPCLK = 0x02,
+
+ ///
+ /// i2c data channel
+ ///
+ I2CSDA = 0x04,
+
+ ///
+ /// i2c clock channel
+ ///
+ I2CSCL = 0x08,
+
+ ///
+ /// SPI Master Out, Slave In channel
+ ///
+ SPIMOSI = 0x10,
+
+ ///
+ /// SPI Master In, Slave Out channel
+ ///
+ SPIMISO = 0x20,
+
+ ///
+ /// SPI Clock channel
+ ///
+ SPICLK = 0x40,
+
+ ///
+ /// SPI Chip Select Channel
+ ///
+ SPICS = 0x80,
+
+ ///
+ /// UART Request to Send Channel
+ ///
+ UARTRTS = 0x100,
+
+ ///
+ /// UART Transmit Channel
+ ///
+ UARTTXD = 0x200,
+
+ ///
+ /// UART Receive Channel
+ ///
+ UARTRXD = 0x400,
+
+ ///
+ /// Hardware Pule Width Modulation
+ ///
+ PWM = 0x800,
+ }
+
+ ///
+ /// The PWM mode.
+ ///
+ public enum PwmMode {
+ ///
+ /// PWM pulses are sent using mark-sign patterns (old school)
+ ///
+ MarkSign = 0,
+
+ ///
+ /// PWM pulses are sent as a balanced signal (default, newer mode)
+ ///
+ Balanced = 1,
+ }
+
+ ///
+ /// Defines GPIO controller initialization modes.
+ ///
+ internal enum ControllerMode {
+ ///
+ /// The not initialized
+ ///
+ NotInitialized,
+
+ ///
+ /// The direct with wiring pi pins
+ ///
+ DirectWithWiringPiPins,
+
+ ///
+ /// The direct with BCM pins
+ ///
+ DirectWithBcmPins,
+
+ ///
+ /// The direct with header pins
+ ///
+ DirectWithHeaderPins,
+
+ ///
+ /// The file stream with hardware pins
+ ///
+ FileStreamWithHardwarePins,
+ }
}
diff --git a/Unosquare.WiringPi/GpioController.cs b/Unosquare.WiringPi/GpioController.cs
index cc30710..eb4c712 100644
--- a/Unosquare.WiringPi/GpioController.cs
+++ b/Unosquare.WiringPi/GpioController.cs
@@ -1,582 +1,557 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
- using Swan;
- using System;
- using System.Collections;
- using System.Collections.Generic;
- using System.Collections.ObjectModel;
- using System.Linq;
- using System.Threading.Tasks;
-
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Swan;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Represents the Raspberry Pi GPIO controller
+ /// as an IReadOnlyCollection of GpioPins.
+ ///
+ /// Low level operations are accomplished by using the Wiring Pi library.
+ ///
+ public sealed class GpioController : IGpioController {
+ #region Private Declarations
+
+ private const String WiringPiCodesEnvironmentVariable = "WIRINGPI_CODES";
+ private static readonly Object SyncRoot = new Object();
+ private readonly List _pins;
+
+ #endregion
+
+ #region Constructors and Initialization
+
///
- /// Represents the Raspberry Pi GPIO controller
- /// as an IReadOnlyCollection of GpioPins.
- ///
- /// Low level operations are accomplished by using the Wiring Pi library.
+ /// Initializes static members of the class.
///
- public sealed class GpioController : IGpioController
- {
- #region Private Declarations
-
- private const string WiringPiCodesEnvironmentVariable = "WIRINGPI_CODES";
- private static readonly object SyncRoot = new object();
- private readonly List _pins;
-
- #endregion
-
- #region Constructors and Initialization
-
- ///
- /// Initializes static members of the class.
- ///
- static GpioController()
- {
- var wiringPiEdgeDetection = new Dictionary
- {
- {EdgeDetection.FallingEdge, 21},
- {EdgeDetection.RisingEdge, 1},
- {EdgeDetection.FallingAndRisingEdge, 3},
- };
-
- WiringPiEdgeDetectionMapping = new ReadOnlyDictionary(wiringPiEdgeDetection);
- }
-
- ///
- /// Initializes a new instance of the class.
- ///
- /// Unable to initialize the GPIO controller.
- internal GpioController()
- {
- if (_pins != null)
- return;
-
- if (IsInitialized == false)
- {
- var initResult = Initialize(ControllerMode.DirectWithBcmPins);
- if (initResult == false)
- throw new Exception("Unable to initialize the GPIO controller.");
- }
-
- _pins = new List
- {
- GpioPin.Pin00.Value,
- GpioPin.Pin01.Value,
- GpioPin.Pin02.Value,
- GpioPin.Pin03.Value,
- GpioPin.Pin04.Value,
- GpioPin.Pin05.Value,
- GpioPin.Pin06.Value,
- GpioPin.Pin07.Value,
- GpioPin.Pin08.Value,
- GpioPin.Pin09.Value,
- GpioPin.Pin10.Value,
- GpioPin.Pin11.Value,
- GpioPin.Pin12.Value,
- GpioPin.Pin13.Value,
- GpioPin.Pin14.Value,
- GpioPin.Pin15.Value,
- GpioPin.Pin16.Value,
- GpioPin.Pin17.Value,
- GpioPin.Pin18.Value,
- GpioPin.Pin19.Value,
- GpioPin.Pin20.Value,
- GpioPin.Pin21.Value,
- GpioPin.Pin22.Value,
- GpioPin.Pin23.Value,
- GpioPin.Pin24.Value,
- GpioPin.Pin25.Value,
- GpioPin.Pin26.Value,
- GpioPin.Pin27.Value,
- GpioPin.Pin28.Value,
- GpioPin.Pin29.Value,
- GpioPin.Pin30.Value,
- GpioPin.Pin31.Value,
- };
-
- var headerP1 = new Dictionary(_pins.Count);
- var headerP5 = new Dictionary(_pins.Count);
- foreach (var pin in _pins)
- {
- if (pin.PhysicalPinNumber < 0)
- continue;
-
- var header = pin.Header == GpioHeader.P1 ? headerP1 : headerP5;
- header[pin.PhysicalPinNumber] = pin;
- }
-
- HeaderP1 = new ReadOnlyDictionary(headerP1);
- HeaderP5 = new ReadOnlyDictionary(headerP5);
- }
-
- ///
- /// Determines if the underlying GPIO controller has been initialized properly.
- ///
- ///
- /// true if the controller is properly initialized; otherwise, false.
- ///
- public static bool IsInitialized
- {
- get
- {
- lock (SyncRoot)
- {
- return Mode != ControllerMode.NotInitialized;
- }
- }
- }
-
- ///
- /// Gets the wiring pi edge detection mapping.
- ///
- internal static ReadOnlyDictionary WiringPiEdgeDetectionMapping { get; }
-
- ///
- ///
- /// Gets the number of registered pins in the controller.
- ///
- public int Count => Pins.Count;
-
- ///
- /// Gets or sets the initialization mode.
- ///
- private static ControllerMode Mode { get; set; } = ControllerMode.NotInitialized;
-
- #endregion
-
- #region Pin Addressing
-
- ///
- /// Gets the PWM base frequency (in Hz).
- ///
- public int PwmBaseFrequency => 19200000;
-
- ///
- /// Gets a red-only collection of all pins.
- ///
- public ReadOnlyCollection Pins => new ReadOnlyCollection(_pins);
-
- ///
- /// Provides all the pins on Header P1 of the Pi as a lookup by physical header pin number.
- /// This header is the main header and it is the one commonly used.
- ///
- public ReadOnlyDictionary HeaderP1 { get; }
-
- ///
- /// Provides all the pins on Header P5 of the Pi as a lookup by physical header pin number.
- /// This header is the secondary header and it is rarely used.
- ///
- public ReadOnlyDictionary HeaderP5 { get; }
-
- #endregion
-
- #region Individual Pin Properties
-
- ///
- /// Provides direct access to Pin known as BCM0.
- ///
- public GpioPin Pin00 => GpioPin.Pin00.Value;
-
- ///
- /// Provides direct access to Pin known as BCM1.
- ///
- public GpioPin Pin01 => GpioPin.Pin01.Value;
-
- ///
- /// Provides direct access to Pin known as BCM2.
- ///
- public GpioPin Pin02 => GpioPin.Pin02.Value;
-
- ///
- /// Provides direct access to Pin known as BCM3.
- ///
- public GpioPin Pin03 => GpioPin.Pin03.Value;
-
- ///
- /// Provides direct access to Pin known as BCM4.
- ///
- public GpioPin Pin04 => GpioPin.Pin04.Value;
-
- ///
- /// Provides direct access to Pin known as BCM5.
- ///
- public GpioPin Pin05 => GpioPin.Pin05.Value;
-
- ///
- /// Provides direct access to Pin known as BCM6.
- ///
- public GpioPin Pin06 => GpioPin.Pin06.Value;
-
- ///
- /// Provides direct access to Pin known as BCM7.
- ///
- public GpioPin Pin07 => GpioPin.Pin07.Value;
-
- ///
- /// Provides direct access to Pin known as BCM8.
- ///
- public GpioPin Pin08 => GpioPin.Pin08.Value;
-
- ///
- /// Provides direct access to Pin known as BCM9.
- ///
- public GpioPin Pin09 => GpioPin.Pin09.Value;
-
- ///
- /// Provides direct access to Pin known as BCM10.
- ///
- public GpioPin Pin10 => GpioPin.Pin10.Value;
-
- ///
- /// Provides direct access to Pin known as BCM11.
- ///
- public GpioPin Pin11 => GpioPin.Pin11.Value;
-
- ///
- /// Provides direct access to Pin known as BCM12.
- ///
- public GpioPin Pin12 => GpioPin.Pin12.Value;
-
- ///
- /// Provides direct access to Pin known as BCM13.
- ///
- public GpioPin Pin13 => GpioPin.Pin13.Value;
-
- ///
- /// Provides direct access to Pin known as BCM14.
- ///
- public GpioPin Pin14 => GpioPin.Pin14.Value;
-
- ///
- /// Provides direct access to Pin known as BCM15.
- ///
- public GpioPin Pin15 => GpioPin.Pin15.Value;
-
- ///
- /// Provides direct access to Pin known as BCM16.
- ///
- public GpioPin Pin16 => GpioPin.Pin16.Value;
-
- ///
- /// Provides direct access to Pin known as BCM17.
- ///
- public GpioPin Pin17 => GpioPin.Pin17.Value;
-
- ///
- /// Provides direct access to Pin known as BCM18.
- ///
- public GpioPin Pin18 => GpioPin.Pin18.Value;
-
- ///
- /// Provides direct access to Pin known as BCM19.
- ///
- public GpioPin Pin19 => GpioPin.Pin19.Value;
-
- ///
- /// Provides direct access to Pin known as BCM20.
- ///
- public GpioPin Pin20 => GpioPin.Pin20.Value;
-
- ///
- /// Provides direct access to Pin known as BCM21.
- ///
- public GpioPin Pin21 => GpioPin.Pin21.Value;
-
- ///
- /// Provides direct access to Pin known as BCM22.
- ///
- public GpioPin Pin22 => GpioPin.Pin22.Value;
-
- ///
- /// Provides direct access to Pin known as BCM23.
- ///
- public GpioPin Pin23 => GpioPin.Pin23.Value;
-
- ///
- /// Provides direct access to Pin known as BCM24.
- ///
- public GpioPin Pin24 => GpioPin.Pin24.Value;
-
- ///
- /// Provides direct access to Pin known as BCM25.
- ///
- public GpioPin Pin25 => GpioPin.Pin25.Value;
-
- ///
- /// Provides direct access to Pin known as BCM26.
- ///
- public GpioPin Pin26 => GpioPin.Pin26.Value;
-
- ///
- /// Provides direct access to Pin known as BCM27.
- ///
- public GpioPin Pin27 => GpioPin.Pin27.Value;
-
- ///
- /// Provides direct access to Pin known as BCM28 (available on Header P5).
- ///
- public GpioPin Pin28 => GpioPin.Pin28.Value;
-
- ///
- /// Provides direct access to Pin known as BCM29 (available on Header P5).
- ///
- public GpioPin Pin29 => GpioPin.Pin29.Value;
-
- ///
- /// Provides direct access to Pin known as BCM30 (available on Header P5).
- ///
- public GpioPin Pin30 => GpioPin.Pin30.Value;
-
- ///
- /// Provides direct access to Pin known as BCM31 (available on Header P5).
- ///
- public GpioPin Pin31 => GpioPin.Pin31.Value;
-
- #endregion
-
- #region Indexers
-
- ///
- public IGpioPin this[BcmPin bcmPin] => Pins[(int)bcmPin];
-
- ///
- public IGpioPin this[int bcmPinNumber]
- {
- get
- {
- if (!Enum.IsDefined(typeof(BcmPin), bcmPinNumber))
- throw new IndexOutOfRangeException($"Pin {bcmPinNumber} is not registered in the GPIO controller.");
-
- return Pins[bcmPinNumber];
- }
- }
-
- ///
- public IGpioPin this[P1 pinNumber] => HeaderP1[(int)pinNumber];
-
- ///
- public IGpioPin this[P5 pinNumber] => HeaderP5[(int)pinNumber];
-
- ///
- /// Gets the with the specified Wiring Pi pin number.
- ///
- ///
- /// The .
- ///
- /// The pin number.
- /// A reference to the GPIO pin.
- public GpioPin this[WiringPiPin pinNumber]
- {
- get
- {
- if (pinNumber == WiringPiPin.Unknown)
- throw new InvalidOperationException("You can not get an unknown WiringPi pin.");
-
- return Pins.First(p => p.WiringPiPinNumber == pinNumber);
- }
- }
-
- #endregion
-
- #region Pin Group Methods (Read, Write, Pad Drive)
-
- ///
- /// This sets the “strength” of the pad drivers for a particular group of pins.
- /// There are 3 groups of pins and the drive strength is from 0 to 7.
- /// Do not use this unless you know what you are doing.
- ///
- /// The group.
- /// The value.
- public void SetPadDrive(int group, int value)
- {
- lock (SyncRoot)
- {
- WiringPi.SetPadDrive(group, value);
- }
- }
-
- ///
- /// This sets the “strength” of the pad drivers for a particular group of pins.
- /// There are 3 groups of pins and the drive strength is from 0 to 7.
- /// Do not use this unless you know what you are doing.
- ///
- /// The group.
- /// The value.
- /// The awaitable task.
- public Task SetPadDriveAsync(int group, int value) =>
- Task.Run(() => SetPadDrive(group, value));
-
- ///
- /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to set all 8 bits at once to a particular value,
- /// although it still takes two write operations to the Pi’s GPIO hardware.
- ///
- /// The value.
- /// PinMode.
- public void WriteByte(byte value)
- {
- lock (SyncRoot)
- {
- if (this.Skip(0).Take(8).Any(p => p.PinMode != GpioPinDriveMode.Output))
- {
- throw new InvalidOperationException(
- $"All first 8 pins (0 to 7) need their {nameof(GpioPin.PinMode)} to be set to {GpioPinDriveMode.Output}");
- }
-
- WiringPi.DigitalWriteByte(value);
- }
- }
-
- ///
- /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to set all 8 bits at once to a particular value,
- /// although it still takes two write operations to the Pi’s GPIO hardware.
- ///
- /// The value.
- /// The awaitable task.
- public Task WriteByteAsync(byte value) =>
- Task.Run(() => WriteByte(value));
-
- ///
- /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to get all 8 bits at once to a particular value.
- /// Please note this function is undocumented and unsupported.
- ///
- /// A byte from the GPIO.
- /// PinMode.
- public byte ReadByte()
- {
- lock (SyncRoot)
- {
- if (this.Skip(0).Take(8).Any(p =>
- p.PinMode != GpioPinDriveMode.Input && p.PinMode != GpioPinDriveMode.Output))
- {
- throw new InvalidOperationException(
- $"All first 8 pins (0 to 7) need their {nameof(GpioPin.PinMode)} to be set to {GpioPinDriveMode.Input} or {GpioPinDriveMode.Output}");
- }
-
- return (byte)WiringPi.DigitalReadByte();
- }
- }
-
- ///
- /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to get all 8 bits at once to a particular value.
- /// Please note this function is undocumented and unsupported.
- ///
- /// A byte from the GPIO.
- public Task ReadByteAsync() =>
- Task.Run(ReadByte);
-
- #endregion
-
- #region IReadOnlyCollection Implementation
-
- ///
- /// Returns an enumerator that iterates through the collection.
- ///
- ///
- /// A that can be used to iterate through the collection.
- ///
- public IEnumerator GetEnumerator() => Pins.GetEnumerator();
-
- ///
- IEnumerator IEnumerable.GetEnumerator() => Pins.GetEnumerator();
-
- ///
- IEnumerator IEnumerable.GetEnumerator() => Pins.GetEnumerator();
-
- #endregion
-
- #region Helper and Init Methods
-
- ///
- /// Converts the Wirings Pi pin number to the BCM pin number.
- ///
- /// The wiring pi pin number.
- /// The converted pin.
- internal static int WiringPiToBcmPinNumber(int wiringPiPinNumber)
- {
- lock (SyncRoot)
- {
- return WiringPi.WpiPinToGpio(wiringPiPinNumber);
- }
- }
-
- ///
- /// Converts the Physical (Header) pin number to BCM pin number.
- ///
- /// The header pin number.
- /// The converted pin.
- internal static int HaderToBcmPinNumber(int headerPinNumber)
- {
- lock (SyncRoot)
- {
- return WiringPi.PhysPinToGpio(headerPinNumber);
- }
- }
-
- ///
- /// Initializes the controller given the initialization mode and pin numbering scheme.
- ///
- /// The mode.
- /// True when successful.
- ///
- /// This library does not support the platform.
- ///
- /// Library was already Initialized.
- /// The init mode is invalid.
- private bool Initialize(ControllerMode mode)
- {
- if (SwanRuntime.OS != Swan.OperatingSystem.Unix)
- throw new PlatformNotSupportedException("This library does not support the platform");
-
- lock (SyncRoot)
- {
- if (IsInitialized)
- throw new InvalidOperationException($"Cannot call {nameof(Initialize)} more than once.");
-
- Environment.SetEnvironmentVariable(WiringPiCodesEnvironmentVariable, "1");
- int setupResult;
-
- switch (mode)
- {
- case ControllerMode.DirectWithWiringPiPins:
- {
- setupResult = WiringPi.WiringPiSetup();
- break;
- }
-
- case ControllerMode.DirectWithBcmPins:
- {
- setupResult = WiringPi.WiringPiSetupGpio();
- break;
- }
-
- case ControllerMode.DirectWithHeaderPins:
- {
- setupResult = WiringPi.WiringPiSetupPhys();
- break;
- }
-
- case ControllerMode.FileStreamWithHardwarePins:
- {
- setupResult = WiringPi.WiringPiSetupSys();
- break;
- }
-
- default:
- {
- throw new ArgumentException($"'{mode}' is not a valid initialization mode.");
- }
- }
-
- Mode = setupResult == 0 ? mode : ControllerMode.NotInitialized;
- return IsInitialized;
- }
- }
- #endregion
-
- }
+ static GpioController() {
+ Dictionary wiringPiEdgeDetection = new Dictionary
+ {
+ {EdgeDetection.FallingEdge, 21},
+ {EdgeDetection.RisingEdge, 1},
+ {EdgeDetection.FallingAndRisingEdge, 3}
+ };
+
+ WiringPiEdgeDetectionMapping = new ReadOnlyDictionary(wiringPiEdgeDetection);
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Unable to initialize the GPIO controller.
+ internal GpioController() {
+ if(this._pins != null) {
+ return;
+ }
+
+ if(IsInitialized == false) {
+ Boolean initResult = this.Initialize(ControllerMode.DirectWithBcmPins);
+ if(initResult == false) {
+ throw new Exception("Unable to initialize the GPIO controller.");
+ }
+ }
+
+ this._pins = new List {
+ GpioPin.Pin00.Value,
+ GpioPin.Pin01.Value,
+ GpioPin.Pin02.Value,
+ GpioPin.Pin03.Value,
+ GpioPin.Pin04.Value,
+ GpioPin.Pin05.Value,
+ GpioPin.Pin06.Value,
+ GpioPin.Pin07.Value,
+ GpioPin.Pin08.Value,
+ GpioPin.Pin09.Value,
+ GpioPin.Pin10.Value,
+ GpioPin.Pin11.Value,
+ GpioPin.Pin12.Value,
+ GpioPin.Pin13.Value,
+ GpioPin.Pin14.Value,
+ GpioPin.Pin15.Value,
+ GpioPin.Pin16.Value,
+ GpioPin.Pin17.Value,
+ GpioPin.Pin18.Value,
+ GpioPin.Pin19.Value,
+ GpioPin.Pin20.Value,
+ GpioPin.Pin21.Value,
+ GpioPin.Pin22.Value,
+ GpioPin.Pin23.Value,
+ GpioPin.Pin24.Value,
+ GpioPin.Pin25.Value,
+ GpioPin.Pin26.Value,
+ GpioPin.Pin27.Value,
+ GpioPin.Pin28.Value,
+ GpioPin.Pin29.Value,
+ GpioPin.Pin30.Value,
+ GpioPin.Pin31.Value,
+ };
+
+ Dictionary headerP1 = new Dictionary(this._pins.Count);
+ Dictionary headerP5 = new Dictionary(this._pins.Count);
+ foreach(GpioPin pin in this._pins) {
+ if(pin.PhysicalPinNumber < 0) {
+ continue;
+ }
+
+ Dictionary header = pin.Header == GpioHeader.P1 ? headerP1 : headerP5;
+ header[pin.PhysicalPinNumber] = pin;
+ }
+
+ this.HeaderP1 = new ReadOnlyDictionary(headerP1);
+ this.HeaderP5 = new ReadOnlyDictionary(headerP5);
+ }
+
+ ///
+ /// Determines if the underlying GPIO controller has been initialized properly.
+ ///
+ ///
+ /// true if the controller is properly initialized; otherwise, false.
+ ///
+ public static Boolean IsInitialized {
+ get {
+ lock(SyncRoot) {
+ return Mode != ControllerMode.NotInitialized;
+ }
+ }
+ }
+
+ ///
+ /// Gets the wiring pi edge detection mapping.
+ ///
+ internal static ReadOnlyDictionary WiringPiEdgeDetectionMapping {
+ get;
+ }
+
+ ///
+ ///
+ /// Gets the number of registered pins in the controller.
+ ///
+ public Int32 Count => this.Pins.Count;
+
+ ///
+ /// Gets or sets the initialization mode.
+ ///
+ private static ControllerMode Mode { get; set; } = ControllerMode.NotInitialized;
+
+ #endregion
+
+ #region Pin Addressing
+
+ ///
+ /// Gets the PWM base frequency (in Hz).
+ ///
+ public Int32 PwmBaseFrequency => 19200000;
+
+ ///
+ /// Gets a red-only collection of all pins.
+ ///
+ public ReadOnlyCollection Pins => new ReadOnlyCollection(this._pins);
+
+ ///
+ /// Provides all the pins on Header P1 of the Pi as a lookup by physical header pin number.
+ /// This header is the main header and it is the one commonly used.
+ ///
+ public ReadOnlyDictionary HeaderP1 {
+ get;
+ }
+
+ ///
+ /// Provides all the pins on Header P5 of the Pi as a lookup by physical header pin number.
+ /// This header is the secondary header and it is rarely used.
+ ///
+ public ReadOnlyDictionary HeaderP5 {
+ get;
+ }
+
+ #endregion
+
+ #region Individual Pin Properties
+
+ ///
+ /// Provides direct access to Pin known as BCM0.
+ ///
+ public GpioPin Pin00 => GpioPin.Pin00.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM1.
+ ///
+ public GpioPin Pin01 => GpioPin.Pin01.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM2.
+ ///
+ public GpioPin Pin02 => GpioPin.Pin02.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM3.
+ ///
+ public GpioPin Pin03 => GpioPin.Pin03.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM4.
+ ///
+ public GpioPin Pin04 => GpioPin.Pin04.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM5.
+ ///
+ public GpioPin Pin05 => GpioPin.Pin05.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM6.
+ ///
+ public GpioPin Pin06 => GpioPin.Pin06.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM7.
+ ///
+ public GpioPin Pin07 => GpioPin.Pin07.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM8.
+ ///
+ public GpioPin Pin08 => GpioPin.Pin08.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM9.
+ ///
+ public GpioPin Pin09 => GpioPin.Pin09.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM10.
+ ///
+ public GpioPin Pin10 => GpioPin.Pin10.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM11.
+ ///
+ public GpioPin Pin11 => GpioPin.Pin11.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM12.
+ ///
+ public GpioPin Pin12 => GpioPin.Pin12.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM13.
+ ///
+ public GpioPin Pin13 => GpioPin.Pin13.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM14.
+ ///
+ public GpioPin Pin14 => GpioPin.Pin14.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM15.
+ ///
+ public GpioPin Pin15 => GpioPin.Pin15.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM16.
+ ///
+ public GpioPin Pin16 => GpioPin.Pin16.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM17.
+ ///
+ public GpioPin Pin17 => GpioPin.Pin17.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM18.
+ ///
+ public GpioPin Pin18 => GpioPin.Pin18.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM19.
+ ///
+ public GpioPin Pin19 => GpioPin.Pin19.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM20.
+ ///
+ public GpioPin Pin20 => GpioPin.Pin20.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM21.
+ ///
+ public GpioPin Pin21 => GpioPin.Pin21.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM22.
+ ///
+ public GpioPin Pin22 => GpioPin.Pin22.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM23.
+ ///
+ public GpioPin Pin23 => GpioPin.Pin23.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM24.
+ ///
+ public GpioPin Pin24 => GpioPin.Pin24.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM25.
+ ///
+ public GpioPin Pin25 => GpioPin.Pin25.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM26.
+ ///
+ public GpioPin Pin26 => GpioPin.Pin26.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM27.
+ ///
+ public GpioPin Pin27 => GpioPin.Pin27.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM28 (available on Header P5).
+ ///
+ public GpioPin Pin28 => GpioPin.Pin28.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM29 (available on Header P5).
+ ///
+ public GpioPin Pin29 => GpioPin.Pin29.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM30 (available on Header P5).
+ ///
+ public GpioPin Pin30 => GpioPin.Pin30.Value;
+
+ ///
+ /// Provides direct access to Pin known as BCM31 (available on Header P5).
+ ///
+ public GpioPin Pin31 => GpioPin.Pin31.Value;
+
+ #endregion
+
+ #region Indexers
+
+ ///
+ public IGpioPin this[BcmPin bcmPin] => this.Pins[(Int32)bcmPin];
+
+ ///
+ public IGpioPin this[Int32 bcmPinNumber] {
+ get {
+ if(!Enum.IsDefined(typeof(BcmPin), bcmPinNumber)) {
+ throw new IndexOutOfRangeException($"Pin {bcmPinNumber} is not registered in the GPIO controller.");
+ }
+
+ return this.Pins[bcmPinNumber];
+ }
+ }
+
+ ///
+ public IGpioPin this[P1 pinNumber] => this.HeaderP1[(Int32)pinNumber];
+
+ ///
+ public IGpioPin this[P5 pinNumber] => this.HeaderP5[(Int32)pinNumber];
+
+ ///
+ /// Gets the with the specified Wiring Pi pin number.
+ ///
+ ///
+ /// The .
+ ///
+ /// The pin number.
+ /// A reference to the GPIO pin.
+ public GpioPin this[WiringPiPin pinNumber] {
+ get {
+ if(pinNumber == WiringPiPin.Unknown) {
+ throw new InvalidOperationException("You can not get an unknown WiringPi pin.");
+ }
+
+ return this.Pins.First(p => p.WiringPiPinNumber == pinNumber);
+ }
+ }
+
+ #endregion
+
+ #region Pin Group Methods (Read, Write, Pad Drive)
+
+ ///
+ /// This sets the “strength” of the pad drivers for a particular group of pins.
+ /// There are 3 groups of pins and the drive strength is from 0 to 7.
+ /// Do not use this unless you know what you are doing.
+ ///
+ /// The group.
+ /// The value.
+ public void SetPadDrive(Int32 group, Int32 value) {
+ lock(SyncRoot) {
+ _ = Native.WiringPi.SetPadDrive(group, value);
+ }
+ }
+
+ ///
+ /// This sets the “strength” of the pad drivers for a particular group of pins.
+ /// There are 3 groups of pins and the drive strength is from 0 to 7.
+ /// Do not use this unless you know what you are doing.
+ ///
+ /// The group.
+ /// The value.
+ /// The awaitable task.
+ public Task SetPadDriveAsync(Int32 group, Int32 value) => Task.Run(() => this.SetPadDrive(group, value));
+
+ ///
+ /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to set all 8 bits at once to a particular value,
+ /// although it still takes two write operations to the Pi’s GPIO hardware.
+ ///
+ /// The value.
+ /// PinMode.
+ public void WriteByte(Byte value) {
+ lock(SyncRoot) {
+ if(this.Skip(0).Take(8).Any(p => p.PinMode != GpioPinDriveMode.Output)) {
+ throw new InvalidOperationException($"All first 8 pins (0 to 7) need their {nameof(GpioPin.PinMode)} to be set to {GpioPinDriveMode.Output}");
+ }
+
+ Native.WiringPi.DigitalWriteByte(value);
+ }
+ }
+
+ ///
+ /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to set all 8 bits at once to a particular value,
+ /// although it still takes two write operations to the Pi’s GPIO hardware.
+ ///
+ /// The value.
+ /// The awaitable task.
+ public Task WriteByteAsync(Byte value) => Task.Run(() => this.WriteByte(value));
+
+ ///
+ /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to get all 8 bits at once to a particular value.
+ /// Please note this function is undocumented and unsupported.
+ ///
+ /// A byte from the GPIO.
+ /// PinMode.
+ public Byte ReadByte() {
+ lock(SyncRoot) {
+ if(this.Skip(0).Take(8).Any(p =>
+ p.PinMode != GpioPinDriveMode.Input && p.PinMode != GpioPinDriveMode.Output)) {
+ throw new InvalidOperationException($"All first 8 pins (0 to 7) need their {nameof(GpioPin.PinMode)} to be set to {GpioPinDriveMode.Input} or {GpioPinDriveMode.Output}");
+ }
+
+ return (Byte)Native.WiringPi.DigitalReadByte();
+ }
+ }
+
+ ///
+ /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to get all 8 bits at once to a particular value.
+ /// Please note this function is undocumented and unsupported.
+ ///
+ /// A byte from the GPIO.
+ public Task ReadByteAsync() => Task.Run(this.ReadByte);
+
+ #endregion
+
+ #region IReadOnlyCollection Implementation
+
+ ///
+ /// Returns an enumerator that iterates through the collection.
+ ///
+ ///
+ /// A that can be used to iterate through the collection.
+ ///
+ public IEnumerator GetEnumerator() => this.Pins.GetEnumerator();
+
+ ///
+ IEnumerator IEnumerable.GetEnumerator() => this.Pins.GetEnumerator();
+
+ ///
+ IEnumerator IEnumerable.GetEnumerator() => this.Pins.GetEnumerator();
+
+ #endregion
+
+ #region Helper and Init Methods
+
+ ///
+ /// Converts the Wirings Pi pin number to the BCM pin number.
+ ///
+ /// The wiring pi pin number.
+ /// The converted pin.
+ internal static Int32 WiringPiToBcmPinNumber(Int32 wiringPiPinNumber) {
+ lock(SyncRoot) {
+ return Native.WiringPi.WpiPinToGpio(wiringPiPinNumber);
+ }
+ }
+
+ ///
+ /// Converts the Physical (Header) pin number to BCM pin number.
+ ///
+ /// The header pin number.
+ /// The converted pin.
+ internal static Int32 HaderToBcmPinNumber(Int32 headerPinNumber) {
+ lock(SyncRoot) {
+ return Native.WiringPi.PhysPinToGpio(headerPinNumber);
+ }
+ }
+
+ ///
+ /// Initializes the controller given the initialization mode and pin numbering scheme.
+ ///
+ /// The mode.
+ /// True when successful.
+ ///
+ /// This library does not support the platform.
+ ///
+ /// Library was already Initialized.
+ /// The init mode is invalid.
+ private Boolean Initialize(ControllerMode mode) {
+ if(SwanRuntime.OS != Swan.OperatingSystem.Unix) {
+ throw new PlatformNotSupportedException("This library does not support the platform");
+ }
+
+ lock(SyncRoot) {
+ if(IsInitialized) {
+ throw new InvalidOperationException($"Cannot call {nameof(Initialize)} more than once.");
+ }
+
+ Environment.SetEnvironmentVariable(WiringPiCodesEnvironmentVariable, "1");
+ Int32 setupResult;
+
+ switch(mode) {
+ case ControllerMode.DirectWithWiringPiPins: {
+ setupResult = Native.WiringPi.WiringPiSetup();
+ break;
+ }
+
+ case ControllerMode.DirectWithBcmPins: {
+ setupResult = Native.WiringPi.WiringPiSetupGpio();
+ break;
+ }
+
+ case ControllerMode.DirectWithHeaderPins: {
+ setupResult = Native.WiringPi.WiringPiSetupPhys();
+ break;
+ }
+
+ case ControllerMode.FileStreamWithHardwarePins: {
+ setupResult = Native.WiringPi.WiringPiSetupSys();
+ break;
+ }
+
+ default: {
+ throw new ArgumentException($"'{mode}' is not a valid initialization mode.");
+ }
+ }
+
+ Mode = setupResult == 0 ? mode : ControllerMode.NotInitialized;
+ return IsInitialized;
+ }
+ }
+ #endregion
+
+ }
}
diff --git a/Unosquare.WiringPi/GpioPin.Factory.cs b/Unosquare.WiringPi/GpioPin.Factory.cs
index 2cffb47..f061d16 100644
--- a/Unosquare.WiringPi/GpioPin.Factory.cs
+++ b/Unosquare.WiringPi/GpioPin.Factory.cs
@@ -1,200 +1,167 @@
-namespace Unosquare.WiringPi
-{
- using RaspberryIO.Abstractions;
- using System;
-
- public partial class GpioPin
- {
- internal static readonly Lazy Pin00 = new Lazy(() => new GpioPin(BcmPin.Gpio00)
- {
- Capabilities = PinCapability.GP | PinCapability.I2CSDA,
- Name = $"BCM 0 {(SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? "(SDA)" : "(ID_SD)")}",
- });
-
- internal static readonly Lazy Pin01 = new Lazy(() => new GpioPin(BcmPin.Gpio01)
- {
- Capabilities = PinCapability.GP | PinCapability.I2CSCL,
- Name = $"BCM 1 {(SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? "(SCL)" : "(ID_SC)")}",
- });
-
- internal static readonly Lazy Pin02 = new Lazy(() => new GpioPin(BcmPin.Gpio02)
- {
- Capabilities = PinCapability.GP | PinCapability.I2CSDA,
- Name = "BCM 2 (SDA)",
- });
-
- internal static readonly Lazy Pin03 = new Lazy(() => new GpioPin(BcmPin.Gpio03)
- {
- Capabilities = PinCapability.GP | PinCapability.I2CSCL,
- Name = "BCM 3 (SCL)",
- });
-
- internal static readonly Lazy Pin04 = new Lazy(() => new GpioPin(BcmPin.Gpio04)
- {
- Capabilities = PinCapability.GP | PinCapability.GPCLK,
- Name = "BCM 4 (GPCLK0)",
- });
-
- internal static readonly Lazy Pin05 = new Lazy(() => new GpioPin(BcmPin.Gpio05)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 5",
- });
-
- internal static readonly Lazy Pin06 = new Lazy(() => new GpioPin(BcmPin.Gpio06)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 6",
- });
-
- internal static readonly Lazy Pin07 = new Lazy(() => new GpioPin(BcmPin.Gpio07)
- {
- Capabilities = PinCapability.GP | PinCapability.SPICS,
- Name = "BCM 7 (CE1)",
- });
-
- internal static readonly Lazy Pin08 = new Lazy(() => new GpioPin(BcmPin.Gpio08)
- {
- Capabilities = PinCapability.GP | PinCapability.SPICS,
- Name = "BCM 8 (CE0)",
- });
-
- internal static readonly Lazy Pin09 = new Lazy(() => new GpioPin(BcmPin.Gpio09)
- {
- Capabilities = PinCapability.GP | PinCapability.SPIMISO,
- Name = "BCM 9 (MISO)",
- });
-
- internal static readonly Lazy Pin10 = new Lazy(() => new GpioPin(BcmPin.Gpio10)
- {
- Capabilities = PinCapability.GP | PinCapability.SPIMOSI,
- Name = "BCM 10 (MOSI)",
- });
-
- internal static readonly Lazy Pin11 = new Lazy(() => new GpioPin(BcmPin.Gpio11)
- {
- Capabilities = PinCapability.GP | PinCapability.SPICLK,
- Name = "BCM 11 (SCLCK)",
- });
-
- internal static readonly Lazy Pin12 = new Lazy(() => new GpioPin(BcmPin.Gpio12)
- {
- Capabilities = PinCapability.GP | PinCapability.PWM,
- Name = "BCM 12 (PWM0)",
- });
-
- internal static readonly Lazy Pin13 = new Lazy(() => new GpioPin(BcmPin.Gpio13)
- {
- Capabilities = PinCapability.GP | PinCapability.PWM,
- Name = "BCM 13 (PWM1)",
- });
-
- internal static readonly Lazy Pin14 = new Lazy(() => new GpioPin(BcmPin.Gpio14)
- {
- Capabilities = PinCapability.UARTTXD,
- Name = "BCM 14 (TXD)",
- });
-
- internal static readonly Lazy Pin15 = new Lazy(() => new GpioPin(BcmPin.Gpio15)
- {
- Capabilities = PinCapability.UARTRXD,
- Name = "BCM 15 (RXD)",
- });
-
- internal static readonly Lazy Pin16 = new Lazy(() => new GpioPin(BcmPin.Gpio16)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 16",
- });
-
- internal static readonly Lazy Pin17 = new Lazy(() => new GpioPin(BcmPin.Gpio17)
- {
- Capabilities = PinCapability.GP | PinCapability.UARTRTS,
- Name = "BCM 17",
- });
-
- internal static readonly Lazy Pin18 = new Lazy(() => new GpioPin(BcmPin.Gpio18)
- {
- Capabilities = PinCapability.GP | PinCapability.PWM,
- Name = "BCM 18 (PWM0)",
- });
-
- internal static readonly Lazy Pin19 = new Lazy(() => new GpioPin(BcmPin.Gpio19)
- {
- Capabilities = PinCapability.GP | PinCapability.PWM | PinCapability.SPIMISO,
- Name = "BCM 19 (MISO)",
- });
-
- internal static readonly Lazy Pin20 = new Lazy(() => new GpioPin(BcmPin.Gpio20)
- {
- Capabilities = PinCapability.GP | PinCapability.SPIMOSI,
- Name = "BCM 20 (MOSI)",
- });
-
- internal static readonly Lazy Pin21 = new Lazy(() => new GpioPin(BcmPin.Gpio21)
- {
- Capabilities = PinCapability.GP | PinCapability.SPICLK,
- Name = $"BCM 21{(SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? string.Empty : " (SCLK)")}",
- });
-
- internal static readonly Lazy Pin22 = new Lazy(() => new GpioPin(BcmPin.Gpio22)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 22",
- });
-
- internal static readonly Lazy Pin23 = new Lazy(() => new GpioPin(BcmPin.Gpio23)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 23",
- });
-
- internal static readonly Lazy Pin24 = new Lazy(() => new GpioPin(BcmPin.Gpio24)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 24",
- });
-
- internal static readonly Lazy Pin25 = new Lazy(() => new GpioPin(BcmPin.Gpio25)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 25",
- });
-
- internal static readonly Lazy Pin26 = new Lazy(() => new GpioPin(BcmPin.Gpio26)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 26",
- });
-
- internal static readonly Lazy Pin27 = new Lazy(() => new GpioPin(BcmPin.Gpio27)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 27",
- });
-
- internal static readonly Lazy Pin28 = new Lazy(() => new GpioPin(BcmPin.Gpio28)
- {
- Capabilities = PinCapability.GP | PinCapability.I2CSDA,
- Name = "BCM 28 (SDA)",
- });
-
- internal static readonly Lazy Pin29 = new Lazy(() => new GpioPin(BcmPin.Gpio29)
- {
- Capabilities = PinCapability.GP | PinCapability.I2CSCL,
- Name = "BCM 29 (SCL)",
- });
-
- internal static readonly Lazy Pin30 = new Lazy(() => new GpioPin(BcmPin.Gpio30)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 30",
- });
-
- internal static readonly Lazy Pin31 = new Lazy(() => new GpioPin(BcmPin.Gpio31)
- {
- Capabilities = PinCapability.GP,
- Name = "BCM 31",
- });
- }
+using System;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ public partial class GpioPin {
+ internal static readonly Lazy Pin00 = new Lazy(() => new GpioPin(BcmPin.Gpio00) {
+ Capabilities = PinCapability.GP | PinCapability.I2CSDA,
+ Name = $"BCM 0 {(SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? "(SDA)" : "(ID_SD)")}",
+ });
+
+ internal static readonly Lazy Pin01 = new Lazy(() => new GpioPin(BcmPin.Gpio01) {
+ Capabilities = PinCapability.GP | PinCapability.I2CSCL,
+ Name = $"BCM 1 {(SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? "(SCL)" : "(ID_SC)")}",
+ });
+
+ internal static readonly Lazy Pin02 = new Lazy(() => new GpioPin(BcmPin.Gpio02) {
+ Capabilities = PinCapability.GP | PinCapability.I2CSDA,
+ Name = "BCM 2 (SDA)",
+ });
+
+ internal static readonly Lazy Pin03 = new Lazy(() => new GpioPin(BcmPin.Gpio03) {
+ Capabilities = PinCapability.GP | PinCapability.I2CSCL,
+ Name = "BCM 3 (SCL)",
+ });
+
+ internal static readonly Lazy Pin04 = new Lazy(() => new GpioPin(BcmPin.Gpio04) {
+ Capabilities = PinCapability.GP | PinCapability.GPCLK,
+ Name = "BCM 4 (GPCLK0)",
+ });
+
+ internal static readonly Lazy Pin05 = new Lazy(() => new GpioPin(BcmPin.Gpio05) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 5",
+ });
+
+ internal static readonly Lazy Pin06 = new Lazy(() => new GpioPin(BcmPin.Gpio06) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 6",
+ });
+
+ internal static readonly Lazy Pin07 = new Lazy(() => new GpioPin(BcmPin.Gpio07) {
+ Capabilities = PinCapability.GP | PinCapability.SPICS,
+ Name = "BCM 7 (CE1)",
+ });
+
+ internal static readonly Lazy Pin08 = new Lazy(() => new GpioPin(BcmPin.Gpio08) {
+ Capabilities = PinCapability.GP | PinCapability.SPICS,
+ Name = "BCM 8 (CE0)",
+ });
+
+ internal static readonly Lazy Pin09 = new Lazy(() => new GpioPin(BcmPin.Gpio09) {
+ Capabilities = PinCapability.GP | PinCapability.SPIMISO,
+ Name = "BCM 9 (MISO)",
+ });
+
+ internal static readonly Lazy Pin10 = new Lazy(() => new GpioPin(BcmPin.Gpio10) {
+ Capabilities = PinCapability.GP | PinCapability.SPIMOSI,
+ Name = "BCM 10 (MOSI)",
+ });
+
+ internal static readonly Lazy Pin11 = new Lazy(() => new GpioPin(BcmPin.Gpio11) {
+ Capabilities = PinCapability.GP | PinCapability.SPICLK,
+ Name = "BCM 11 (SCLCK)",
+ });
+
+ internal static readonly Lazy Pin12 = new Lazy(() => new GpioPin(BcmPin.Gpio12) {
+ Capabilities = PinCapability.GP | PinCapability.PWM,
+ Name = "BCM 12 (PWM0)",
+ });
+
+ internal static readonly Lazy Pin13 = new Lazy(() => new GpioPin(BcmPin.Gpio13) {
+ Capabilities = PinCapability.GP | PinCapability.PWM,
+ Name = "BCM 13 (PWM1)",
+ });
+
+ internal static readonly Lazy Pin14 = new Lazy(() => new GpioPin(BcmPin.Gpio14) {
+ Capabilities = PinCapability.UARTTXD,
+ Name = "BCM 14 (TXD)",
+ });
+
+ internal static readonly Lazy Pin15 = new Lazy(() => new GpioPin(BcmPin.Gpio15) {
+ Capabilities = PinCapability.UARTRXD,
+ Name = "BCM 15 (RXD)",
+ });
+
+ internal static readonly Lazy Pin16 = new Lazy(() => new GpioPin(BcmPin.Gpio16) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 16",
+ });
+
+ internal static readonly Lazy Pin17 = new Lazy(() => new GpioPin(BcmPin.Gpio17) {
+ Capabilities = PinCapability.GP | PinCapability.UARTRTS,
+ Name = "BCM 17",
+ });
+
+ internal static readonly Lazy Pin18 = new Lazy(() => new GpioPin(BcmPin.Gpio18) {
+ Capabilities = PinCapability.GP | PinCapability.PWM,
+ Name = "BCM 18 (PWM0)",
+ });
+
+ internal static readonly Lazy Pin19 = new Lazy(() => new GpioPin(BcmPin.Gpio19) {
+ Capabilities = PinCapability.GP | PinCapability.PWM | PinCapability.SPIMISO,
+ Name = "BCM 19 (MISO)",
+ });
+
+ internal static readonly Lazy Pin20 = new Lazy(() => new GpioPin(BcmPin.Gpio20) {
+ Capabilities = PinCapability.GP | PinCapability.SPIMOSI,
+ Name = "BCM 20 (MOSI)",
+ });
+
+ internal static readonly Lazy Pin21 = new Lazy(() => new GpioPin(BcmPin.Gpio21) {
+ Capabilities = PinCapability.GP | PinCapability.SPICLK,
+ Name = $"BCM 21{(SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? String.Empty : " (SCLK)")}",
+ });
+
+ internal static readonly Lazy Pin22 = new Lazy(() => new GpioPin(BcmPin.Gpio22) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 22",
+ });
+
+ internal static readonly Lazy Pin23 = new Lazy(() => new GpioPin(BcmPin.Gpio23) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 23",
+ });
+
+ internal static readonly Lazy Pin24 = new Lazy(() => new GpioPin(BcmPin.Gpio24) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 24",
+ });
+
+ internal static readonly Lazy Pin25 = new Lazy(() => new GpioPin(BcmPin.Gpio25) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 25",
+ });
+
+ internal static readonly Lazy Pin26 = new Lazy(() => new GpioPin(BcmPin.Gpio26) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 26",
+ });
+
+ internal static readonly Lazy Pin27 = new Lazy(() => new GpioPin(BcmPin.Gpio27) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 27",
+ });
+
+ internal static readonly Lazy Pin28 = new Lazy(() => new GpioPin(BcmPin.Gpio28) {
+ Capabilities = PinCapability.GP | PinCapability.I2CSDA,
+ Name = "BCM 28 (SDA)",
+ });
+
+ internal static readonly Lazy Pin29 = new Lazy(() => new GpioPin(BcmPin.Gpio29) {
+ Capabilities = PinCapability.GP | PinCapability.I2CSCL,
+ Name = "BCM 29 (SCL)",
+ });
+
+ internal static readonly Lazy Pin30 = new Lazy(() => new GpioPin(BcmPin.Gpio30) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 30",
+ });
+
+ internal static readonly Lazy Pin31 = new Lazy(() => new GpioPin(BcmPin.Gpio31) {
+ Capabilities = PinCapability.GP,
+ Name = "BCM 31",
+ });
+ }
}
\ No newline at end of file
diff --git a/Unosquare.WiringPi/GpioPin.cs b/Unosquare.WiringPi/GpioPin.cs
index e65ecf9..8fec72f 100644
--- a/Unosquare.WiringPi/GpioPin.cs
+++ b/Unosquare.WiringPi/GpioPin.cs
@@ -1,654 +1,583 @@
-namespace Unosquare.WiringPi
-{
- using System;
- using System.Threading.Tasks;
- using Native;
- using RaspberryIO.Abstractions;
- using RaspberryIO.Abstractions.Native;
- using Swan.Diagnostics;
- using Definitions = RaspberryIO.Abstractions.Definitions;
-
+using System;
+using System.Threading.Tasks;
+
+using Swan.Diagnostics;
+
+using Unosquare.RaspberryIO.Abstractions;
+using Unosquare.RaspberryIO.Abstractions.Native;
+
+using Definitions = Unosquare.RaspberryIO.Abstractions.Definitions;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Represents a GPIO Pin, its location and its capabilities.
+ /// Full pin reference available here:
+ /// http://pinout.xyz/pinout/pin31_gpio6 and http://wiringpi.com/pins/.
+ ///
+ public sealed partial class GpioPin : IGpioPin {
+ #region Property Backing
+
+ private static readonly Int32[] GpioToWiringPi;
+
+ private static readonly Int32[] GpioToWiringPiR1 = { 8, 9, -1, -1, 7, -1, -1, 11, 10, 13, 12, 14, -1, -1, 15, 16, -1, 0, 1, -1, -1, 2, 3, 4, 5, 6, -1, -1, -1, -1, -1, -1 };
+
+ private static readonly Int32[] GpioToWiringPiR2 = { 30, 31, 8, 9, 7, 21, 22, 11, 10, 13, 12, 14, 26, 23, 15, 16, 27, 0, 1, 24, 28, 29, 3, 4, 5, 6, 25, 2, 17, 18, 19, 20 };
+
+ private readonly Object _syncLock = new Object();
+ private GpioPinDriveMode _pinMode;
+ private GpioPinResistorPullMode _resistorPullMode;
+ private Int32 _pwmRegister;
+ private PwmMode _pwmMode = PwmMode.Balanced;
+ private UInt32 _pwmRange = 1024;
+ private Int32 _pwmClockDivisor = 1;
+ private Int32 _softPwmValue = -1;
+ private Int32 _softToneFrequency = -1;
+
+ #endregion
+
+ #region Constructor
+
+ static GpioPin() => GpioToWiringPi = SystemInfo.GetBoardRevision() == BoardRevision.Rev1 ? GpioToWiringPiR1 : GpioToWiringPiR2;
+
///
- /// Represents a GPIO Pin, its location and its capabilities.
- /// Full pin reference available here:
- /// http://pinout.xyz/pinout/pin31_gpio6 and http://wiringpi.com/pins/.
+ /// Initializes a new instance of the class.
///
- public sealed partial class GpioPin : IGpioPin
- {
- #region Property Backing
-
- private static readonly int[] GpioToWiringPi;
-
- private static readonly int[] GpioToWiringPiR1 =
- {
- 8, 9, -1, -1, 7, -1, -1, 11, 10, 13, 12, 14, -1, -1, 15, 16, -1, 0, 1, -1, -1, 2, 3, 4, 5, 6, -1, -1, -1, -1, -1, -1,
- };
-
- private static readonly int[] GpioToWiringPiR2 =
- {
- 30, 31, 8, 9, 7, 21, 22, 11, 10, 13, 12, 14, 26, 23, 15, 16, 27, 0, 1, 24, 28, 29, 3, 4, 5, 6, 25, 2, 17, 18, 19, 20,
- };
-
- private readonly object _syncLock = new object();
- private GpioPinDriveMode _pinMode;
- private GpioPinResistorPullMode _resistorPullMode;
- private int _pwmRegister;
- private PwmMode _pwmMode = PwmMode.Balanced;
- private uint _pwmRange = 1024;
- private int _pwmClockDivisor = 1;
- private int _softPwmValue = -1;
- private int _softToneFrequency = -1;
-
- #endregion
-
- #region Constructor
-
- static GpioPin()
- {
- GpioToWiringPi = SystemInfo.GetBoardRevision() ==
- BoardRevision.Rev1 ? GpioToWiringPiR1 : GpioToWiringPiR2;
- }
-
- ///
- /// Initializes a new instance of the class.
- ///
- /// The BCM pin number.
- private GpioPin(BcmPin bcmPinNumber)
- {
- BcmPin = bcmPinNumber;
- BcmPinNumber = (int)bcmPinNumber;
-
- WiringPiPinNumber = BcmToWiringPiPinNumber(bcmPinNumber);
- PhysicalPinNumber = Definitions.BcmToPhysicalPinNumber(SystemInfo.GetBoardRevision(), bcmPinNumber);
- Header = (BcmPinNumber >= 28 && BcmPinNumber <= 31) ? GpioHeader.P5 : GpioHeader.P1;
- }
-
- #endregion
-
- #region Pin Properties
-
- ///
- public BcmPin BcmPin { get; }
-
- ///
- public int BcmPinNumber { get; }
-
- ///
- public int PhysicalPinNumber { get; }
-
- ///
- /// Gets the WiringPi Pin number.
- ///
- public WiringPiPin WiringPiPinNumber { get; }
-
- ///
- public GpioHeader Header { get; }
-
- ///
- /// Gets the friendly name of the pin.
- ///
- public string Name { get; private set; }
-
- ///
- /// Gets the hardware mode capabilities of this pin.
- ///
- public PinCapability Capabilities { get; private set; }
-
- ///
- public bool Value
- {
- get => Read();
- set => Write(value);
- }
-
- #endregion
-
- #region Hardware-Specific Properties
-
- ///
- /// Thrown when a pin does not support the given operation mode.
- public GpioPinDriveMode PinMode
- {
- get => _pinMode;
-
- set
- {
- lock (_syncLock)
- {
- var mode = value;
- if ((mode == GpioPinDriveMode.GpioClock && !HasCapability(PinCapability.GPCLK)) ||
- (mode == GpioPinDriveMode.PwmOutput && !HasCapability(PinCapability.PWM)) ||
- (mode == GpioPinDriveMode.Input && !HasCapability(PinCapability.GP)) ||
- (mode == GpioPinDriveMode.Output && !HasCapability(PinCapability.GP)))
- {
- throw new NotSupportedException(
- $"Pin {BcmPinNumber} '{Name}' does not support mode '{mode}'. Pin capabilities are limited to: {Capabilities}");
- }
-
- WiringPi.PinMode(BcmPinNumber, (int)mode);
- _pinMode = mode;
- }
- }
- }
-
- ///
- /// Gets the interrupt callback. Returns null if no interrupt
- /// has been registered.
- ///
- public InterruptServiceRoutineCallback InterruptCallback { get; private set; }
-
- ///
- /// Gets the interrupt edge detection mode.
- ///
- public EdgeDetection InterruptEdgeDetection { get; private set; }
-
- ///
- /// Determines whether the specified capability has capability.
- ///
- /// The capability.
- ///
- /// true if the specified capability has capability; otherwise, false.
- ///
- public bool HasCapability(PinCapability capability) =>
- (Capabilities & capability) == capability;
-
- #endregion
-
- #region Hardware PWM Members
-
- ///
- public GpioPinResistorPullMode InputPullMode
- {
- get => PinMode == GpioPinDriveMode.Input ? _resistorPullMode : GpioPinResistorPullMode.Off;
-
- set
- {
- lock (_syncLock)
- {
- if (PinMode != GpioPinDriveMode.Input)
- {
- _resistorPullMode = GpioPinResistorPullMode.Off;
- throw new InvalidOperationException(
- $"Unable to set the {nameof(InputPullMode)} for pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Setting the {nameof(InputPullMode)} is only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Input}");
- }
-
- WiringPi.PullUpDnControl(BcmPinNumber, (int)value);
- _resistorPullMode = value;
- }
- }
- }
-
- ///
- /// Gets or sets the PWM register.
- ///
- ///
- /// The PWM register.
- ///
- public int PwmRegister
- {
- get => _pwmRegister;
-
- set
- {
- lock (_syncLock)
- {
- if (!HasCapability(PinCapability.PWM))
- {
- _pwmRegister = 0;
-
- throw new NotSupportedException(
- $"Pin {BcmPinNumber} '{Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {Capabilities}");
- }
-
- WiringPi.PwmWrite(BcmPinNumber, value);
- _pwmRegister = value;
- }
- }
- }
-
- ///
- /// The PWM generator can run in 2 modes – “balanced” and “mark:space”. The mark:space mode is traditional,
- /// however the default mode in the Pi is “balanced”.
- ///
- ///
- /// The PWM mode.
- ///
- /// When pin mode is not set a Pwn output.
- public PwmMode PwmMode
- {
- get => PinMode == GpioPinDriveMode.PwmOutput ? _pwmMode : PwmMode.Balanced;
-
- set
- {
- lock (_syncLock)
- {
- if (!HasCapability(PinCapability.PWM))
- {
- _pwmMode = PwmMode.Balanced;
-
- throw new NotSupportedException(
- $"Pin {BcmPinNumber} '{Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {Capabilities}");
- }
-
- WiringPi.PwmSetMode((int)value);
- _pwmMode = value;
- }
- }
- }
-
- ///
- /// This sets the range register in the PWM generator. The default is 1024.
- ///
- ///
- /// The PWM range.
- ///
- /// When pin mode is not set to PWM output.
- public uint PwmRange
- {
- get => PinMode == GpioPinDriveMode.PwmOutput ? _pwmRange : 0;
-
- set
- {
- lock (_syncLock)
- {
- if (!HasCapability(PinCapability.PWM))
- {
- _pwmRange = 1024;
-
- throw new NotSupportedException(
- $"Pin {BcmPinNumber} '{Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {Capabilities}");
- }
-
- WiringPi.PwmSetRange(value);
- _pwmRange = value;
- }
- }
- }
-
- ///
- /// Gets or sets the PWM clock divisor.
- ///
- ///
- /// The PWM clock divisor.
- ///
- /// When pin mode is not set to PWM output.
- public int PwmClockDivisor
- {
- get => PinMode == GpioPinDriveMode.PwmOutput ? _pwmClockDivisor : 0;
-
- set
- {
- lock (_syncLock)
- {
- if (!HasCapability(PinCapability.PWM))
- {
- _pwmClockDivisor = 1;
-
- throw new NotSupportedException(
- $"Pin {BcmPinNumber} '{Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {Capabilities}");
- }
-
- WiringPi.PwmSetClock(value);
- _pwmClockDivisor = value;
- }
- }
- }
-
- #endregion
-
- #region Software Tone Members
-
- ///
- /// Gets a value indicating whether this instance is in software based tone generator mode.
- ///
- ///
- /// true if this instance is in soft tone mode; otherwise, false.
- ///
- public bool IsInSoftToneMode => _softToneFrequency >= 0;
-
- ///
- /// Gets or sets the soft tone frequency. 0 to 5000 Hz is typical.
- ///
- ///
- /// The soft tone frequency.
- ///
- /// When soft tones cannot be initialized on the pin.
- public int SoftToneFrequency
- {
- get => _softToneFrequency;
-
- set
- {
- lock (_syncLock)
- {
- if (IsInSoftToneMode == false)
- {
- var setupResult = WiringPi.SoftToneCreate(BcmPinNumber);
- if (setupResult != 0)
- {
- throw new InvalidOperationException(
- $"Unable to initialize soft tone on pin {BcmPinNumber}. Error Code: {setupResult}");
- }
- }
-
- WiringPi.SoftToneWrite(BcmPinNumber, value);
- _softToneFrequency = value;
- }
- }
- }
-
- #endregion
-
- #region Software PWM Members
-
- ///
- /// Gets a value indicating whether this pin is in software based PWM mode.
- ///
- ///
- /// true if this instance is in soft PWM mode; otherwise, false.
- ///
- public bool IsInSoftPwmMode => _softPwmValue >= 0;
-
- ///
- /// Gets or sets the software PWM value on the pin.
- ///
- ///
- /// The soft PWM value.
- ///
- /// StartSoftPwm.
- public int SoftPwmValue
- {
- get => _softPwmValue;
-
- set
- {
- lock (_syncLock)
- {
- if (IsInSoftPwmMode && value >= 0)
- {
- WiringPi.SoftPwmWrite(BcmPinNumber, value);
- _softPwmValue = value;
- }
- else
- {
- throw new InvalidOperationException($"Software PWM requires a call to {nameof(StartSoftPwm)}.");
- }
- }
- }
- }
-
- ///
- /// Gets the software PWM range used upon starting the PWM.
- ///
- public int SoftPwmRange { get; private set; } = -1;
-
- ///
- /// Starts the software based PWM on this pin.
- ///
- /// The value.
- /// The range.
- /// When the pin does not suppoert PWM.
- /// StartSoftPwm
- /// or.
- public void StartSoftPwm(int value, int range)
- {
- lock (_syncLock)
- {
- if (!HasCapability(PinCapability.GP))
- throw new NotSupportedException($"Pin {BcmPinNumber} does not support software PWM");
-
- if (IsInSoftPwmMode)
- throw new InvalidOperationException($"{nameof(StartSoftPwm)} has already been called.");
-
- var startResult = WiringPi.SoftPwmCreate(BcmPinNumber, value, range);
-
- if (startResult == 0)
- {
- _softPwmValue = value;
- SoftPwmRange = range;
- }
- else
- {
- throw new InvalidOperationException(
- $"Could not start software based PWM on pin {BcmPinNumber}. Error code: {startResult}");
- }
- }
- }
-
- #endregion
-
- #region Output Mode (Write) Members
-
- ///
- public void Write(GpioPinValue value)
- {
- lock (_syncLock)
- {
- if (PinMode != GpioPinDriveMode.Output)
- {
- throw new InvalidOperationException(
- $"Unable to write to pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Writes are only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Output}");
- }
-
- WiringPi.DigitalWrite(BcmPinNumber, (int)value);
- }
- }
-
- ///
- /// Writes the value asynchronously.
- ///
- /// The value.
- /// The awaitable task.
- public Task WriteAsync(GpioPinValue value) => Task.Run(() => { Write(value); });
-
- ///
- /// Writes the specified bit value.
- /// This method performs a digital write.
- ///
- /// if set to true [value].
- public void Write(bool value)
- => Write(value ? GpioPinValue.High : GpioPinValue.Low);
-
- ///
- /// Writes the specified bit value.
- /// This method performs a digital write.
- ///
- /// The value.
- ///
- /// The awaitable task.
- ///
- public Task WriteAsync(bool value) => Task.Run(() => { Write(value); });
-
- ///
- /// Writes the specified value. 0 for low, any other value for high
- /// This method performs a digital write.
- ///
- /// The value.
- public void Write(int value) => Write(value != 0 ? GpioPinValue.High : GpioPinValue.Low);
-
- ///
- /// Writes the specified value. 0 for low, any other value for high
- /// This method performs a digital write.
- ///
- /// The value.
- /// The awaitable task.
- public Task WriteAsync(int value) => Task.Run(() => { Write(value); });
-
- ///
- /// Writes the specified value as an analog level.
- /// You will need to register additional analog modules to enable this function for devices such as the Gertboard.
- ///
- /// The value.
- public void WriteLevel(int value)
- {
- lock (_syncLock)
- {
- if (PinMode != GpioPinDriveMode.Output)
- {
- throw new InvalidOperationException(
- $"Unable to write to pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Writes are only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Output}");
- }
-
- WiringPi.AnalogWrite(BcmPinNumber, value);
- }
- }
-
- ///
- /// Writes the specified value as an analog level.
- /// You will need to register additional analog modules to enable this function for devices such as the Gertboard.
- ///
- /// The value.
- /// The awaitable task.
- public Task WriteLevelAsync(int value) => Task.Run(() => { WriteLevel(value); });
-
- #endregion
-
- #region Input Mode (Read) Members
-
- ///
- /// Wait for specific pin status.
- ///
- /// status to check.
- /// timeout to reach status.
- /// true/false.
- public bool WaitForValue(GpioPinValue status, int timeOutMillisecond)
- {
- if (PinMode != GpioPinDriveMode.Input)
- {
- throw new InvalidOperationException(
- $"Unable to read from pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Reads are only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Input}");
- }
-
- var hrt = new HighResolutionTimer();
- hrt.Start();
- do
- {
- if (ReadValue() == status)
- return true;
- }
- while (hrt.ElapsedMilliseconds <= timeOutMillisecond);
-
- return false;
- }
-
- ///
- /// Reads the digital value on the pin as a boolean value.
- ///
- /// The state of the pin.
- public bool Read()
- {
- lock (_syncLock)
- {
- if (PinMode != GpioPinDriveMode.Input && PinMode != GpioPinDriveMode.Output)
- {
- throw new InvalidOperationException(
- $"Unable to read from pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Reads are only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Input} or {GpioPinDriveMode.Output}");
- }
-
- return WiringPi.DigitalRead(BcmPinNumber) != 0;
- }
- }
-
- ///
- /// Reads the digital value on the pin as a boolean value.
- ///
- /// The state of the pin.
- public Task ReadAsync() => Task.Run(Read);
-
- ///
- /// Reads the digital value on the pin as a High or Low value.
- ///
- /// The state of the pin.
- public GpioPinValue ReadValue()
- => Read() ? GpioPinValue.High : GpioPinValue.Low;
-
- ///
- /// Reads the digital value on the pin as a High or Low value.
- ///
- /// The state of the pin.
- public Task ReadValueAsync() => Task.Run(ReadValue);
-
- ///
- /// Reads the analog value on the pin.
- /// This returns the value read on the supplied analog input pin. You will need to register
- /// additional analog modules to enable this function for devices such as the Gertboard,
- /// quick2Wire analog board, etc.
- ///
- /// The analog level.
- /// When the pin mode is not configured as an input.
- public int ReadLevel()
- {
- lock (_syncLock)
- {
- if (PinMode != GpioPinDriveMode.Input)
- {
- throw new InvalidOperationException(
- $"Unable to read from pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Reads are only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Input}");
- }
-
- return WiringPi.AnalogRead(BcmPinNumber);
- }
- }
-
- ///
- /// Reads the analog value on the pin.
- /// This returns the value read on the supplied analog input pin. You will need to register
- /// additional analog modules to enable this function for devices such as the Gertboard,
- /// quick2Wire analog board, etc.
- ///
- /// The analog level.
- public Task ReadLevelAsync() => Task.Run(ReadLevel);
-
- #endregion
-
- #region Interrupts
-
- ///
- /// callback.
- public void RegisterInterruptCallback(EdgeDetection edgeDetection, Action callback)
- {
- if (callback == null)
- throw new ArgumentNullException(nameof(callback));
-
- if (PinMode != GpioPinDriveMode.Input)
- {
- throw new InvalidOperationException(
- $"Unable to {nameof(RegisterInterruptCallback)} for pin {BcmPinNumber} because operating mode is {PinMode}."
- + $" Calling {nameof(RegisterInterruptCallback)} is only allowed if {nameof(PinMode)} is set to {GpioPinDriveMode.Input}");
- }
-
- lock (_syncLock)
- {
- var isrCallback = new InterruptServiceRoutineCallback(callback);
- var registerResult = WiringPi.WiringPiISR(BcmPinNumber, GetWiringPiEdgeDetection(edgeDetection), isrCallback);
- if (registerResult == 0)
- {
- InterruptEdgeDetection = edgeDetection;
- InterruptCallback = isrCallback;
- }
- else
- {
- HardwareException.Throw(nameof(GpioPin), nameof(RegisterInterruptCallback));
- }
- }
- }
-
- ///
- public void RegisterInterruptCallback(EdgeDetection edgeDetection, Action callback) =>
- throw new NotSupportedException("WiringPi does only support a simple interrupt callback that has no parameters.");
-
- internal static WiringPiPin BcmToWiringPiPinNumber(BcmPin pin) =>
- (WiringPiPin)GpioToWiringPi[(int)pin];
-
- private static int GetWiringPiEdgeDetection(EdgeDetection edgeDetection) =>
- GpioController.WiringPiEdgeDetectionMapping[edgeDetection];
-
- #endregion
- }
+ /// The BCM pin number.
+ private GpioPin(BcmPin bcmPinNumber) {
+ this.BcmPin = bcmPinNumber;
+ this.BcmPinNumber = (Int32)bcmPinNumber;
+
+ this.WiringPiPinNumber = BcmToWiringPiPinNumber(bcmPinNumber);
+ this.PhysicalPinNumber = Definitions.BcmToPhysicalPinNumber(SystemInfo.GetBoardRevision(), bcmPinNumber);
+ this.Header = (this.BcmPinNumber >= 28 && this.BcmPinNumber <= 31) ? GpioHeader.P5 : GpioHeader.P1;
+ }
+
+ #endregion
+
+ #region Pin Properties
+
+ ///
+ public BcmPin BcmPin {
+ get;
+ }
+
+ ///
+ public Int32 BcmPinNumber {
+ get;
+ }
+
+ ///
+ public Int32 PhysicalPinNumber {
+ get;
+ }
+
+ ///
+ /// Gets the WiringPi Pin number.
+ ///
+ public WiringPiPin WiringPiPinNumber {
+ get;
+ }
+
+ ///
+ public GpioHeader Header {
+ get;
+ }
+
+ ///
+ /// Gets the friendly name of the pin.
+ ///
+ public String Name {
+ get; private set;
+ }
+
+ ///
+ /// Gets the hardware mode capabilities of this pin.
+ ///
+ public PinCapability Capabilities {
+ get; private set;
+ }
+
+ ///
+ public Boolean Value {
+ get => this.Read();
+ set => this.Write(value);
+ }
+
+ #endregion
+
+ #region Hardware-Specific Properties
+
+ ///
+ /// Thrown when a pin does not support the given operation mode.
+ public GpioPinDriveMode PinMode {
+ get => this._pinMode;
+
+ set {
+ lock(this._syncLock) {
+ GpioPinDriveMode mode = value;
+ if(mode == GpioPinDriveMode.GpioClock && !this.HasCapability(PinCapability.GPCLK) ||
+ mode == GpioPinDriveMode.PwmOutput && !this.HasCapability(PinCapability.PWM) ||
+ mode == GpioPinDriveMode.Input && !this.HasCapability(PinCapability.GP) ||
+ mode == GpioPinDriveMode.Output && !this.HasCapability(PinCapability.GP)) {
+ throw new NotSupportedException($"Pin {this.BcmPinNumber} '{this.Name}' does not support mode '{mode}'. Pin capabilities are limited to: {this.Capabilities}");
+ }
+
+ Native.WiringPi.PinMode(this.BcmPinNumber, (Int32)mode);
+ this._pinMode = mode;
+ }
+ }
+ }
+
+ ///
+ /// Gets the interrupt callback. Returns null if no interrupt
+ /// has been registered.
+ ///
+ public Native.InterruptServiceRoutineCallback InterruptCallback {
+ get; private set;
+ }
+
+ ///
+ /// Gets the interrupt edge detection mode.
+ ///
+ public EdgeDetection InterruptEdgeDetection {
+ get; private set;
+ }
+
+ ///
+ /// Determines whether the specified capability has capability.
+ ///
+ /// The capability.
+ ///
+ /// true if the specified capability has capability; otherwise, false.
+ ///
+ public Boolean HasCapability(PinCapability capability) => (this.Capabilities & capability) == capability;
+
+ #endregion
+
+ #region Hardware PWM Members
+
+ ///
+ public GpioPinResistorPullMode InputPullMode {
+ get => this.PinMode == GpioPinDriveMode.Input ? this._resistorPullMode : GpioPinResistorPullMode.Off;
+
+ set {
+ lock(this._syncLock) {
+ if(this.PinMode != GpioPinDriveMode.Input) {
+ this._resistorPullMode = GpioPinResistorPullMode.Off;
+ throw new InvalidOperationException($"Unable to set the {nameof(this.InputPullMode)} for pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Setting the {nameof(this.InputPullMode)} is only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Input}");
+ }
+
+ Native.WiringPi.PullUpDnControl(this.BcmPinNumber, (Int32)value);
+ this._resistorPullMode = value;
+ }
+ }
+ }
+
+ ///
+ /// Gets or sets the PWM register.
+ ///
+ ///
+ /// The PWM register.
+ ///
+ public Int32 PwmRegister {
+ get => this._pwmRegister;
+
+ set {
+ lock(this._syncLock) {
+ if(!this.HasCapability(PinCapability.PWM)) {
+ this._pwmRegister = 0;
+
+ throw new NotSupportedException($"Pin {this.BcmPinNumber} '{this.Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {this.Capabilities}");
+ }
+
+ Native.WiringPi.PwmWrite(this.BcmPinNumber, value);
+ this._pwmRegister = value;
+ }
+ }
+ }
+
+ ///
+ /// The PWM generator can run in 2 modes – “balanced” and “mark:space”. The mark:space mode is traditional,
+ /// however the default mode in the Pi is “balanced”.
+ ///
+ ///
+ /// The PWM mode.
+ ///
+ /// When pin mode is not set a Pwn output.
+ public PwmMode PwmMode {
+ get => this.PinMode == GpioPinDriveMode.PwmOutput ? this._pwmMode : PwmMode.Balanced;
+
+ set {
+ lock(this._syncLock) {
+ if(!this.HasCapability(PinCapability.PWM)) {
+ this._pwmMode = PwmMode.Balanced;
+
+ throw new NotSupportedException($"Pin {this.BcmPinNumber} '{this.Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {this.Capabilities}");
+ }
+
+ Native.WiringPi.PwmSetMode((Int32)value);
+ this._pwmMode = value;
+ }
+ }
+ }
+
+ ///
+ /// This sets the range register in the PWM generator. The default is 1024.
+ ///
+ ///
+ /// The PWM range.
+ ///
+ /// When pin mode is not set to PWM output.
+ public UInt32 PwmRange {
+ get => this.PinMode == GpioPinDriveMode.PwmOutput ? this._pwmRange : 0;
+
+ set {
+ lock(this._syncLock) {
+ if(!this.HasCapability(PinCapability.PWM)) {
+ this._pwmRange = 1024;
+
+ throw new NotSupportedException($"Pin {this.BcmPinNumber} '{this.Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {this.Capabilities}");
+ }
+
+ Native.WiringPi.PwmSetRange(value);
+ this._pwmRange = value;
+ }
+ }
+ }
+
+ ///
+ /// Gets or sets the PWM clock divisor.
+ ///
+ ///
+ /// The PWM clock divisor.
+ ///
+ /// When pin mode is not set to PWM output.
+ public Int32 PwmClockDivisor {
+ get => this.PinMode == GpioPinDriveMode.PwmOutput ? this._pwmClockDivisor : 0;
+
+ set {
+ lock(this._syncLock) {
+ if(!this.HasCapability(PinCapability.PWM)) {
+ this._pwmClockDivisor = 1;
+
+ throw new NotSupportedException($"Pin {this.BcmPinNumber} '{this.Name}' does not support mode '{GpioPinDriveMode.PwmOutput}'. Pin capabilities are limited to: {this.Capabilities}");
+ }
+
+ Native.WiringPi.PwmSetClock(value);
+ this._pwmClockDivisor = value;
+ }
+ }
+ }
+
+ #endregion
+
+ #region Software Tone Members
+
+ ///
+ /// Gets a value indicating whether this instance is in software based tone generator mode.
+ ///
+ ///
+ /// true if this instance is in soft tone mode; otherwise, false.
+ ///
+ public Boolean IsInSoftToneMode => this._softToneFrequency >= 0;
+
+ ///
+ /// Gets or sets the soft tone frequency. 0 to 5000 Hz is typical.
+ ///
+ ///
+ /// The soft tone frequency.
+ ///
+ /// When soft tones cannot be initialized on the pin.
+ public Int32 SoftToneFrequency {
+ get => this._softToneFrequency;
+
+ set {
+ lock(this._syncLock) {
+ if(this.IsInSoftToneMode == false) {
+ Int32 setupResult = Native.WiringPi.SoftToneCreate(this.BcmPinNumber);
+ if(setupResult != 0) {
+ throw new InvalidOperationException($"Unable to initialize soft tone on pin {this.BcmPinNumber}. Error Code: {setupResult}");
+ }
+ }
+
+ Native.WiringPi.SoftToneWrite(this.BcmPinNumber, value);
+ this._softToneFrequency = value;
+ }
+ }
+ }
+
+ #endregion
+
+ #region Software PWM Members
+
+ ///
+ /// Gets a value indicating whether this pin is in software based PWM mode.
+ ///
+ ///
+ /// true if this instance is in soft PWM mode; otherwise, false.
+ ///
+ public Boolean IsInSoftPwmMode => this._softPwmValue >= 0;
+
+ ///
+ /// Gets or sets the software PWM value on the pin.
+ ///
+ ///
+ /// The soft PWM value.
+ ///
+ /// StartSoftPwm.
+ public Int32 SoftPwmValue {
+ get => this._softPwmValue;
+
+ set {
+ lock(this._syncLock) {
+ if(this.IsInSoftPwmMode && value >= 0) {
+ Native.WiringPi.SoftPwmWrite(this.BcmPinNumber, value);
+ this._softPwmValue = value;
+ } else {
+ throw new InvalidOperationException($"Software PWM requires a call to {nameof(StartSoftPwm)}.");
+ }
+ }
+ }
+ }
+
+ ///
+ /// Gets the software PWM range used upon starting the PWM.
+ ///
+ public Int32 SoftPwmRange { get; private set; } = -1;
+
+ ///
+ /// Starts the software based PWM on this pin.
+ ///
+ /// The value.
+ /// The range.
+ /// When the pin does not suppoert PWM.
+ /// StartSoftPwm
+ /// or.
+ public void StartSoftPwm(Int32 value, Int32 range) {
+ lock(this._syncLock) {
+ if(!this.HasCapability(PinCapability.GP)) {
+ throw new NotSupportedException($"Pin {this.BcmPinNumber} does not support software PWM");
+ }
+
+ if(this.IsInSoftPwmMode) {
+ throw new InvalidOperationException($"{nameof(StartSoftPwm)} has already been called.");
+ }
+
+ Int32 startResult = Native.WiringPi.SoftPwmCreate(this.BcmPinNumber, value, range);
+
+ if(startResult == 0) {
+ this._softPwmValue = value;
+ this.SoftPwmRange = range;
+ } else {
+ throw new InvalidOperationException($"Could not start software based PWM on pin {this.BcmPinNumber}. Error code: {startResult}");
+ }
+ }
+ }
+
+ #endregion
+
+ #region Output Mode (Write) Members
+
+ ///
+ public void Write(GpioPinValue value) {
+ lock(this._syncLock) {
+ if(this.PinMode != GpioPinDriveMode.Output) {
+ throw new InvalidOperationException($"Unable to write to pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Writes are only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Output}");
+ }
+
+ Native.WiringPi.DigitalWrite(this.BcmPinNumber, (Int32)value);
+ }
+ }
+
+ ///
+ /// Writes the value asynchronously.
+ ///
+ /// The value.
+ /// The awaitable task.
+ public Task WriteAsync(GpioPinValue value) => Task.Run(() => { this.Write(value); });
+
+ ///
+ /// Writes the specified bit value.
+ /// This method performs a digital write.
+ ///
+ /// if set to true [value].
+ public void Write(Boolean value) => this.Write(value ? GpioPinValue.High : GpioPinValue.Low);
+
+ ///
+ /// Writes the specified bit value.
+ /// This method performs a digital write.
+ ///
+ /// The value.
+ ///
+ /// The awaitable task.
+ ///
+ public Task WriteAsync(Boolean value) => Task.Run(() => { this.Write(value); });
+
+ ///
+ /// Writes the specified value. 0 for low, any other value for high
+ /// This method performs a digital write.
+ ///
+ /// The value.
+ public void Write(Int32 value) => this.Write(value != 0 ? GpioPinValue.High : GpioPinValue.Low);
+
+ ///
+ /// Writes the specified value. 0 for low, any other value for high
+ /// This method performs a digital write.
+ ///
+ /// The value.
+ /// The awaitable task.
+ public Task WriteAsync(Int32 value) => Task.Run(() => { this.Write(value); });
+
+ ///
+ /// Writes the specified value as an analog level.
+ /// You will need to register additional analog modules to enable this function for devices such as the Gertboard.
+ ///
+ /// The value.
+ public void WriteLevel(Int32 value) {
+ lock(this._syncLock) {
+ if(this.PinMode != GpioPinDriveMode.Output) {
+ throw new InvalidOperationException($"Unable to write to pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Writes are only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Output}");
+ }
+
+ Native.WiringPi.AnalogWrite(this.BcmPinNumber, value);
+ }
+ }
+
+ ///
+ /// Writes the specified value as an analog level.
+ /// You will need to register additional analog modules to enable this function for devices such as the Gertboard.
+ ///
+ /// The value.
+ /// The awaitable task.
+ public Task WriteLevelAsync(Int32 value) => Task.Run(() => { this.WriteLevel(value); });
+
+ #endregion
+
+ #region Input Mode (Read) Members
+
+ ///
+ /// Wait for specific pin status.
+ ///
+ /// status to check.
+ /// timeout to reach status.
+ /// true/false.
+ public Boolean WaitForValue(GpioPinValue status, Int32 timeOutMillisecond) {
+ if(this.PinMode != GpioPinDriveMode.Input) {
+ throw new InvalidOperationException($"Unable to read from pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Reads are only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Input}");
+ }
+
+ HighResolutionTimer hrt = new HighResolutionTimer();
+ hrt.Start();
+ do {
+ if(this.ReadValue() == status) {
+ return true;
+ }
+ }
+ while(hrt.ElapsedMilliseconds <= timeOutMillisecond);
+
+ return false;
+ }
+
+ ///
+ /// Reads the digital value on the pin as a boolean value.
+ ///
+ /// The state of the pin.
+ public Boolean Read() {
+ lock(this._syncLock) {
+ if(this.PinMode != GpioPinDriveMode.Input && this.PinMode != GpioPinDriveMode.Output) {
+ throw new InvalidOperationException($"Unable to read from pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Reads are only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Input} or {GpioPinDriveMode.Output}");
+ }
+
+ return Native.WiringPi.DigitalRead(this.BcmPinNumber) != 0;
+ }
+ }
+
+ ///
+ /// Reads the digital value on the pin as a boolean value.
+ ///
+ /// The state of the pin.
+ public Task ReadAsync() => Task.Run(this.Read);
+
+ ///
+ /// Reads the digital value on the pin as a High or Low value.
+ ///
+ /// The state of the pin.
+ public GpioPinValue ReadValue() => this.Read() ? GpioPinValue.High : GpioPinValue.Low;
+
+ ///
+ /// Reads the digital value on the pin as a High or Low value.
+ ///
+ /// The state of the pin.
+ public Task ReadValueAsync() => Task.Run(this.ReadValue);
+
+ ///
+ /// Reads the analog value on the pin.
+ /// This returns the value read on the supplied analog input pin. You will need to register
+ /// additional analog modules to enable this function for devices such as the Gertboard,
+ /// quick2Wire analog board, etc.
+ ///
+ /// The analog level.
+ /// When the pin mode is not configured as an input.
+ public Int32 ReadLevel() {
+ lock(this._syncLock) {
+ if(this.PinMode != GpioPinDriveMode.Input) {
+ throw new InvalidOperationException($"Unable to read from pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Reads are only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Input}");
+ }
+
+ return Native.WiringPi.AnalogRead(this.BcmPinNumber);
+ }
+ }
+
+ ///
+ /// Reads the analog value on the pin.
+ /// This returns the value read on the supplied analog input pin. You will need to register
+ /// additional analog modules to enable this function for devices such as the Gertboard,
+ /// quick2Wire analog board, etc.
+ ///
+ /// The analog level.
+ public Task ReadLevelAsync() => Task.Run(this.ReadLevel);
+
+ #endregion
+
+ #region Interrupts
+
+ ///
+ /// callback.
+ public void RegisterInterruptCallback(EdgeDetection edgeDetection, Action callback) {
+ if(callback == null) {
+ throw new ArgumentNullException(nameof(callback));
+ }
+
+ if(this.PinMode != GpioPinDriveMode.Input) {
+ throw new InvalidOperationException($"Unable to {nameof(RegisterInterruptCallback)} for pin {this.BcmPinNumber} because operating mode is {this.PinMode}."
+ + $" Calling {nameof(RegisterInterruptCallback)} is only allowed if {nameof(this.PinMode)} is set to {GpioPinDriveMode.Input}");
+ }
+
+ lock(this._syncLock) {
+ Native.InterruptServiceRoutineCallback isrCallback = new Native.InterruptServiceRoutineCallback(callback);
+ Int32 registerResult = Native.WiringPi.WiringPiISR(this.BcmPinNumber, GetWiringPiEdgeDetection(edgeDetection), isrCallback);
+ if(registerResult == 0) {
+ this.InterruptEdgeDetection = edgeDetection;
+ this.InterruptCallback = isrCallback;
+ } else {
+ HardwareException.Throw(nameof(GpioPin), nameof(RegisterInterruptCallback));
+ }
+ }
+ }
+
+ ///
+ public void RegisterInterruptCallback(EdgeDetection edgeDetection, Action callback) => throw new NotSupportedException("WiringPi does only support a simple interrupt callback that has no parameters.");
+
+ internal static WiringPiPin BcmToWiringPiPinNumber(BcmPin pin) => (WiringPiPin)GpioToWiringPi[(Int32)pin];
+
+ private static Int32 GetWiringPiEdgeDetection(EdgeDetection edgeDetection) => GpioController.WiringPiEdgeDetectionMapping[edgeDetection];
+
+ #endregion
+ }
}
diff --git a/Unosquare.WiringPi/I2CBus.cs b/Unosquare.WiringPi/I2CBus.cs
index 99dad15..925057f 100644
--- a/Unosquare.WiringPi/I2CBus.cs
+++ b/Unosquare.WiringPi/I2CBus.cs
@@ -1,72 +1,70 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
- using System.Collections.Generic;
- using System.Collections.ObjectModel;
- using System.Linq;
-
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ ///
+ ///
+ /// A simple wrapper for the I2c bus on the Raspberry Pi.
+ ///
+ public class I2CBus : II2CBus {
+ // TODO: It would be nice to integrate i2c device detection.
+ private static readonly Object SyncRoot = new Object();
+ private readonly Dictionary _devices = new Dictionary();
+
///
+ public ReadOnlyCollection Devices {
+ get {
+ lock(SyncRoot) {
+ return new ReadOnlyCollection(this._devices.Values.ToArray());
+ }
+ }
+ }
+
+ ///
+ public II2CDevice this[Int32 deviceId] => this.GetDeviceById(deviceId);
+
+ ///
+ public II2CDevice GetDeviceById(Int32 deviceId) {
+ lock(SyncRoot) {
+ return this._devices[deviceId];
+ }
+ }
+
+ ///
+ /// When the device file descriptor is not found.
+ public II2CDevice AddDevice(Int32 deviceId) {
+ lock(SyncRoot) {
+ if(this._devices.ContainsKey(deviceId)) {
+ return this._devices[deviceId];
+ }
+
+ Int32 fileDescriptor = SetupFileDescriptor(deviceId);
+ if(fileDescriptor < 0) {
+ throw new KeyNotFoundException($"Device with id {deviceId} could not be registered with the I2C bus. Error Code: {fileDescriptor}.");
+ }
+
+ I2CDevice device = new I2CDevice(deviceId, fileDescriptor);
+ this._devices[deviceId] = device;
+ return device;
+ }
+ }
+
///
- /// A simple wrapper for the I2c bus on the Raspberry Pi.
+ /// This initializes the I2C system with your given device identifier.
+ /// The ID is the I2C number of the device and you can use the i2cdetect program to find this out.
+ /// wiringPiI2CSetup() will work out which revision Raspberry Pi you have and open the appropriate device in /dev.
+ /// The return value is the standard Linux filehandle, or -1 if any error – in which case, you can consult errno as usual.
///
- public class I2CBus : II2CBus
- {
- // TODO: It would be nice to integrate i2c device detection.
- private static readonly object SyncRoot = new object();
- private readonly Dictionary _devices = new Dictionary();
-
- ///
- public ReadOnlyCollection Devices
- {
- get
- {
- lock (SyncRoot)
- return new ReadOnlyCollection(_devices.Values.ToArray());
- }
- }
-
- ///
- public II2CDevice this[int deviceId] => GetDeviceById(deviceId);
-
- ///
- public II2CDevice GetDeviceById(int deviceId)
- {
- lock (SyncRoot)
- return _devices[deviceId];
- }
-
- ///
- /// When the device file descriptor is not found.
- public II2CDevice AddDevice(int deviceId)
- {
- lock (SyncRoot)
- {
- if (_devices.ContainsKey(deviceId))
- return _devices[deviceId];
-
- var fileDescriptor = SetupFileDescriptor(deviceId);
- if (fileDescriptor < 0)
- throw new KeyNotFoundException($"Device with id {deviceId} could not be registered with the I2C bus. Error Code: {fileDescriptor}.");
-
- var device = new I2CDevice(deviceId, fileDescriptor);
- _devices[deviceId] = device;
- return device;
- }
- }
-
- ///
- /// This initializes the I2C system with your given device identifier.
- /// The ID is the I2C number of the device and you can use the i2cdetect program to find this out.
- /// wiringPiI2CSetup() will work out which revision Raspberry Pi you have and open the appropriate device in /dev.
- /// The return value is the standard Linux filehandle, or -1 if any error – in which case, you can consult errno as usual.
- ///
- /// The device identifier.
- /// The Linux file handle.
- private static int SetupFileDescriptor(int deviceId)
- {
- lock (SyncRoot)
- return WiringPi.WiringPiI2CSetup(deviceId);
- }
- }
+ /// The device identifier.
+ /// The Linux file handle.
+ private static Int32 SetupFileDescriptor(Int32 deviceId) {
+ lock(SyncRoot) {
+ return Native.WiringPi.WiringPiI2CSetup(deviceId);
+ }
+ }
+ }
}
diff --git a/Unosquare.WiringPi/I2CDevice.cs b/Unosquare.WiringPi/I2CDevice.cs
index ae4af68..2b33091 100644
--- a/Unosquare.WiringPi/I2CDevice.cs
+++ b/Unosquare.WiringPi/I2CDevice.cs
@@ -1,181 +1,182 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
- using RaspberryIO.Abstractions.Native;
- using System;
- using System.Threading.Tasks;
-
+using System;
+using System.Threading.Tasks;
+
+using Unosquare.RaspberryIO.Abstractions;
+using Unosquare.RaspberryIO.Abstractions.Native;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Represents a device on the I2C Bus.
+ ///
+ public class I2CDevice : II2CDevice {
+ private readonly Object _syncLock = new Object();
+
///
- /// Represents a device on the I2C Bus.
+ /// Initializes a new instance of the class.
///
- public class I2CDevice : II2CDevice
- {
- private readonly object _syncLock = new object();
-
- ///
- /// Initializes a new instance of the class.
- ///
- /// The device identifier.
- /// The file descriptor.
- internal I2CDevice(int deviceId, int fileDescriptor)
- {
- DeviceId = deviceId;
- FileDescriptor = fileDescriptor;
- }
-
- ///
- public int DeviceId { get; }
-
- ///
- public int FileDescriptor { get; }
-
- ///
- public byte Read()
- {
- lock (_syncLock)
- {
- var result = WiringPi.WiringPiI2CRead(FileDescriptor);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(Read));
- return (byte)result;
- }
- }
-
- ///
- /// Reads a byte from the specified file descriptor.
- ///
- /// The byte from device.
- public Task ReadAsync() => Task.Run(Read);
-
- ///
- /// Reads a buffer of the specified length, one byte at a time.
- ///
- /// The length.
- /// The byte array from device.
- public byte[] Read(int length)
- {
- lock (_syncLock)
- {
- var buffer = new byte[length];
- for (var i = 0; i < length; i++)
- {
- var result = WiringPi.WiringPiI2CRead(FileDescriptor);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(Read));
- buffer[i] = (byte)result;
- }
-
- return buffer;
- }
- }
-
- ///
- /// Reads a buffer of the specified length, one byte at a time.
- ///
- /// The length.
- /// The byte array from device.
- public Task ReadAsync(int length) => Task.Run(() => Read(length));
-
- ///
- /// Writes a byte of data the specified file descriptor.
- ///
- /// The data.
- public void Write(byte data)
- {
- lock (_syncLock)
- {
- var result = WiringPi.WiringPiI2CWrite(FileDescriptor, data);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(Write));
- }
- }
-
- ///
- /// Writes a byte of data the specified file descriptor.
- ///
- /// The data.
- /// The awaitable task.
- public Task WriteAsync(byte data) => Task.Run(() => { Write(data); });
-
- ///
- /// Writes a set of bytes to the specified file descriptor.
- ///
- /// The data.
- public void Write(byte[] data)
- {
- lock (_syncLock)
- {
- foreach (var b in data)
- {
- var result = WiringPi.WiringPiI2CWrite(FileDescriptor, b);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(Write));
- }
- }
- }
-
- ///
- /// Writes a set of bytes to the specified file descriptor.
- ///
- /// The data.
- /// The awaitable task.
- public Task WriteAsync(byte[] data) => Task.Run(() => { Write(data); });
-
- ///
- /// These write an 8 or 16-bit data value into the device register indicated.
- ///
- /// The register.
- /// The data.
- public void WriteAddressByte(int address, byte data)
- {
- lock (_syncLock)
- {
- var result = WiringPi.WiringPiI2CWriteReg8(FileDescriptor, address, data);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(WriteAddressByte));
- }
- }
-
- ///
- /// These write an 8 or 16-bit data value into the device register indicated.
- ///
- /// The register.
- /// The data.
- public void WriteAddressWord(int address, ushort data)
- {
- lock (_syncLock)
- {
- var result = WiringPi.WiringPiI2CWriteReg16(FileDescriptor, address, data);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(WriteAddressWord));
- }
- }
-
- ///
- /// These read an 8 or 16-bit value from the device register indicated.
- ///
- /// The register.
- /// The address byte from device.
- public byte ReadAddressByte(int address)
- {
- lock (_syncLock)
- {
- var result = WiringPi.WiringPiI2CReadReg8(FileDescriptor, address);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(ReadAddressByte));
-
- return (byte)result;
- }
- }
-
- ///
- /// These read an 8 or 16-bit value from the device register indicated.
- ///
- /// The register.
- /// The address word from device.
- public ushort ReadAddressWord(int address)
- {
- lock (_syncLock)
- {
- var result = WiringPi.WiringPiI2CReadReg16(FileDescriptor, address);
- if (result < 0) HardwareException.Throw(nameof(I2CDevice), nameof(ReadAddressWord));
-
- return Convert.ToUInt16(result);
- }
- }
- }
+ /// The device identifier.
+ /// The file descriptor.
+ internal I2CDevice(Int32 deviceId, Int32 fileDescriptor) {
+ this.DeviceId = deviceId;
+ this.FileDescriptor = fileDescriptor;
+ }
+
+ ///
+ public Int32 DeviceId {
+ get;
+ }
+
+ ///
+ public Int32 FileDescriptor {
+ get;
+ }
+
+ ///
+ public Byte Read() {
+ lock(this._syncLock) {
+ Int32 result = Native.WiringPi.WiringPiI2CRead(this.FileDescriptor);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(Read));
+ }
+
+ return (Byte)result;
+ }
+ }
+
+ ///
+ /// Reads a byte from the specified file descriptor.
+ ///
+ /// The byte from device.
+ public Task ReadAsync() => Task.Run(this.Read);
+
+ ///
+ /// Reads a buffer of the specified length, one byte at a time.
+ ///
+ /// The length.
+ /// The byte array from device.
+ public Byte[] Read(Int32 length) {
+ lock(this._syncLock) {
+ Byte[] buffer = new Byte[length];
+ for(Int32 i = 0; i < length; i++) {
+ Int32 result = Native.WiringPi.WiringPiI2CRead(this.FileDescriptor);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(Read));
+ }
+
+ buffer[i] = (Byte)result;
+ }
+
+ return buffer;
+ }
+ }
+
+ ///
+ /// Reads a buffer of the specified length, one byte at a time.
+ ///
+ /// The length.
+ /// The byte array from device.
+ public Task ReadAsync(Int32 length) => Task.Run(() => this.Read(length));
+
+ ///
+ /// Writes a byte of data the specified file descriptor.
+ ///
+ /// The data.
+ public void Write(Byte data) {
+ lock(this._syncLock) {
+ Int32 result = Native.WiringPi.WiringPiI2CWrite(this.FileDescriptor, data);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(Write));
+ }
+ }
+ }
+
+ ///
+ /// Writes a byte of data the specified file descriptor.
+ ///
+ /// The data.
+ /// The awaitable task.
+ public Task WriteAsync(Byte data) => Task.Run(() => this.Write(data));
+
+ ///
+ /// Writes a set of bytes to the specified file descriptor.
+ ///
+ /// The data.
+ public void Write(Byte[] data) {
+ lock(this._syncLock) {
+ foreach(Byte b in data) {
+ Int32 result = Native.WiringPi.WiringPiI2CWrite(this.FileDescriptor, b);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(Write));
+ }
+ }
+ }
+ }
+
+ ///
+ /// Writes a set of bytes to the specified file descriptor.
+ ///
+ /// The data.
+ /// The awaitable task.
+ public Task WriteAsync(Byte[] data) => Task.Run(() => this.Write(data));
+
+ ///
+ /// These write an 8 or 16-bit data value into the device register indicated.
+ ///
+ /// The register.
+ /// The data.
+ public void WriteAddressByte(Int32 address, Byte data) {
+ lock(this._syncLock) {
+ Int32 result = Native.WiringPi.WiringPiI2CWriteReg8(this.FileDescriptor, address, data);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(WriteAddressByte));
+ }
+ }
+ }
+
+ ///
+ /// These write an 8 or 16-bit data value into the device register indicated.
+ ///
+ /// The register.
+ /// The data.
+ public void WriteAddressWord(Int32 address, UInt16 data) {
+ lock(this._syncLock) {
+ Int32 result = Native.WiringPi.WiringPiI2CWriteReg16(this.FileDescriptor, address, data);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(WriteAddressWord));
+ }
+ }
+ }
+
+ ///
+ /// These read an 8 or 16-bit value from the device register indicated.
+ ///
+ /// The register.
+ /// The address byte from device.
+ public Byte ReadAddressByte(Int32 address) {
+ lock(this._syncLock) {
+ Int32 result = Native.WiringPi.WiringPiI2CReadReg8(this.FileDescriptor, address);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(ReadAddressByte));
+ }
+
+ return (Byte)result;
+ }
+ }
+
+ ///
+ /// These read an 8 or 16-bit value from the device register indicated.
+ ///
+ /// The register.
+ /// The address word from device.
+ public UInt16 ReadAddressWord(Int32 address) {
+ lock(this._syncLock) {
+ Int32 result = Native.WiringPi.WiringPiI2CReadReg16(this.FileDescriptor, address);
+ if(result < 0) {
+ HardwareException.Throw(nameof(I2CDevice), nameof(ReadAddressWord));
+ }
+
+ return Convert.ToUInt16(result);
+ }
+ }
+ }
}
diff --git a/Unosquare.WiringPi/Native/Delegates.cs b/Unosquare.WiringPi/Native/Delegates.cs
index 16f9934..66ce0a5 100644
--- a/Unosquare.WiringPi/Native/Delegates.cs
+++ b/Unosquare.WiringPi/Native/Delegates.cs
@@ -1,12 +1,11 @@
-namespace Unosquare.WiringPi.Native
-{
- ///
- /// A delegate defining a callback for an Interrupt Service Routine.
- ///
- public delegate void InterruptServiceRoutineCallback();
-
- ///
- /// Defines the body of a thread worker.
- ///
- public delegate void ThreadWorker();
+namespace Unosquare.WiringPi.Native {
+ ///
+ /// A delegate defining a callback for an Interrupt Service Routine.
+ ///
+ public delegate void InterruptServiceRoutineCallback();
+
+ ///
+ /// Defines the body of a thread worker.
+ ///
+ public delegate void ThreadWorker();
}
diff --git a/Unosquare.WiringPi/Native/SysCall.cs b/Unosquare.WiringPi/Native/SysCall.cs
index d33248d..37e7fef 100644
--- a/Unosquare.WiringPi/Native/SysCall.cs
+++ b/Unosquare.WiringPi/Native/SysCall.cs
@@ -1,19 +1,17 @@
-namespace Unosquare.WiringPi.Native
-{
- using System;
- using System.Runtime.InteropServices;
-
- internal static class SysCall
- {
- internal const string LibCLibrary = "libc";
-
- [DllImport(LibCLibrary, EntryPoint = "chmod", SetLastError = true)]
- public static extern int Chmod(string filename, uint mode);
-
- [DllImport(LibCLibrary, EntryPoint = "strtol", SetLastError = true)]
- public static extern int StringToInteger(string numberString, IntPtr endPointer, int numberBase);
-
- [DllImport(LibCLibrary, EntryPoint = "write", SetLastError = true)]
- public static extern int Write(int fd, byte[] buffer, int count);
- }
+using System;
+using System.Runtime.InteropServices;
+
+namespace Unosquare.WiringPi.Native {
+ internal static class SysCall {
+ internal const String LibCLibrary = "libc";
+
+ [DllImport(LibCLibrary, EntryPoint = "chmod", SetLastError = true)]
+ public static extern Int32 Chmod(String filename, UInt32 mode);
+
+ [DllImport(LibCLibrary, EntryPoint = "strtol", SetLastError = true)]
+ public static extern Int32 StringToInteger(String numberString, IntPtr endPointer, Int32 numberBase);
+
+ [DllImport(LibCLibrary, EntryPoint = "write", SetLastError = true)]
+ public static extern Int32 Write(Int32 fd, Byte[] buffer, Int32 count);
+ }
}
diff --git a/Unosquare.WiringPi/Native/WiringPi.I2C.cs b/Unosquare.WiringPi/Native/WiringPi.I2C.cs
index 56a73d3..404d1ba 100644
--- a/Unosquare.WiringPi/Native/WiringPi.I2C.cs
+++ b/Unosquare.WiringPi/Native/WiringPi.I2C.cs
@@ -1,74 +1,73 @@
-namespace Unosquare.WiringPi.Native
-{
- using System.Runtime.InteropServices;
-
- public partial class WiringPi
- {
- ///
- /// Simple device read. Some devices present data when you read them without having to do any register transactions.
- ///
- /// The fd.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CRead", SetLastError = true)]
- public static extern int WiringPiI2CRead(int fd);
-
- ///
- /// These read an 8-bit value from the device register indicated.
- ///
- /// The fd.
- /// The reg.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CReadReg8", SetLastError = true)]
- public static extern int WiringPiI2CReadReg8(int fd, int reg);
-
- ///
- /// These read a 16-bit value from the device register indicated.
- ///
- /// The fd.
- /// The reg.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CReadReg16", SetLastError = true)]
- public static extern int WiringPiI2CReadReg16(int fd, int reg);
-
- ///
- /// Simple device write. Some devices accept data this way without needing to access any internal registers.
- ///
- /// The fd.
- /// The data.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CWrite", SetLastError = true)]
- public static extern int WiringPiI2CWrite(int fd, int data);
-
- ///
- /// These write an 8-bit data value into the device register indicated.
- ///
- /// The fd.
- /// The reg.
- /// The data.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CWriteReg8", SetLastError = true)]
- public static extern int WiringPiI2CWriteReg8(int fd, int reg, int data);
-
- ///
- /// These write a 16-bit data value into the device register indicated.
- ///
- /// The fd.
- /// The reg.
- /// The data.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CWriteReg16", SetLastError = true)]
- public static extern int WiringPiI2CWriteReg16(int fd, int reg, int data);
-
- ///
- /// This initializes the I2C system with your given device identifier.
- /// The ID is the I2C number of the device and you can use the i2cdetect program to find this out. wiringPiI2CSetup()
- /// will work out which revision Raspberry Pi you have and open the appropriate device in /dev.
- /// The return value is the standard Linux filehandle, or -1 if any error – in which case, you can consult errno as usual.
- /// E.g. the popular MCP23017 GPIO expander is usually device Id 0x20, so this is the number you would pass into wiringPiI2CSetup().
- ///
- /// The dev identifier.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CSetup", SetLastError = true)]
- public static extern int WiringPiI2CSetup(int devId);
- }
+using System;
+using System.Runtime.InteropServices;
+
+namespace Unosquare.WiringPi.Native {
+ public partial class WiringPi {
+ ///
+ /// Simple device read. Some devices present data when you read them without having to do any register transactions.
+ ///
+ /// The fd.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CRead", SetLastError = true)]
+ public static extern Int32 WiringPiI2CRead(Int32 fd);
+
+ ///
+ /// These read an 8-bit value from the device register indicated.
+ ///
+ /// The fd.
+ /// The reg.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CReadReg8", SetLastError = true)]
+ public static extern Int32 WiringPiI2CReadReg8(Int32 fd, Int32 reg);
+
+ ///
+ /// These read a 16-bit value from the device register indicated.
+ ///
+ /// The fd.
+ /// The reg.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CReadReg16", SetLastError = true)]
+ public static extern Int32 WiringPiI2CReadReg16(Int32 fd, Int32 reg);
+
+ ///
+ /// Simple device write. Some devices accept data this way without needing to access any internal registers.
+ ///
+ /// The fd.
+ /// The data.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CWrite", SetLastError = true)]
+ public static extern Int32 WiringPiI2CWrite(Int32 fd, Int32 data);
+
+ ///
+ /// These write an 8-bit data value into the device register indicated.
+ ///
+ /// The fd.
+ /// The reg.
+ /// The data.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CWriteReg8", SetLastError = true)]
+ public static extern Int32 WiringPiI2CWriteReg8(Int32 fd, Int32 reg, Int32 data);
+
+ ///
+ /// These write a 16-bit data value into the device register indicated.
+ ///
+ /// The fd.
+ /// The reg.
+ /// The data.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CWriteReg16", SetLastError = true)]
+ public static extern Int32 WiringPiI2CWriteReg16(Int32 fd, Int32 reg, Int32 data);
+
+ ///
+ /// This initializes the I2C system with your given device identifier.
+ /// The ID is the I2C number of the device and you can use the i2cdetect program to find this out. wiringPiI2CSetup()
+ /// will work out which revision Raspberry Pi you have and open the appropriate device in /dev.
+ /// The return value is the standard Linux filehandle, or -1 if any error – in which case, you can consult errno as usual.
+ /// E.g. the popular MCP23017 GPIO expander is usually device Id 0x20, so this is the number you would pass into wiringPiI2CSetup().
+ ///
+ /// The dev identifier.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiI2CSetup", SetLastError = true)]
+ public static extern Int32 WiringPiI2CSetup(Int32 devId);
+ }
}
diff --git a/Unosquare.WiringPi/Native/WiringPi.SerialPort.cs b/Unosquare.WiringPi/Native/WiringPi.SerialPort.cs
index 5ceb73d..35134d7 100644
--- a/Unosquare.WiringPi/Native/WiringPi.SerialPort.cs
+++ b/Unosquare.WiringPi/Native/WiringPi.SerialPort.cs
@@ -1,69 +1,68 @@
-namespace Unosquare.WiringPi.Native
-{
- using System.Runtime.InteropServices;
-
- public partial class WiringPi
- {
- ///
- /// This opens and initialises the serial device and sets the baud rate. It sets the port into “raw” mode (character at a time and no translations),
- /// and sets the read timeout to 10 seconds. The return value is the file descriptor or -1 for any error, in which case errno will be set as appropriate.
- /// The wiringSerial library is intended to provide simplified control – suitable for most applications, however if you need advanced control
- /// – e.g. parity control, modem control lines (via a USB adapter, there are none on the Pi’s on-board UART!) and so on,
- /// then you need to do some of this the old fashioned way.
- ///
- /// The device.
- /// The baud.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "serialOpen", SetLastError = true)]
- public static extern int SerialOpen(string device, int baud);
-
- ///
- /// Closes the device identified by the file descriptor given.
- ///
- /// The fd.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "serialClose", SetLastError = true)]
- public static extern int SerialClose(int fd);
-
- ///
- /// Sends the single byte to the serial device identified by the given file descriptor.
- ///
- /// The fd.
- /// The c.
- [DllImport(WiringPiLibrary, EntryPoint = "serialPutchar", SetLastError = true)]
- public static extern void SerialPutchar(int fd, byte c);
-
- ///
- /// Sends the nul-terminated string to the serial device identified by the given file descriptor.
- ///
- /// The fd.
- /// The s.
- [DllImport(WiringPiLibrary, EntryPoint = "serialPuts", SetLastError = true)]
- public static extern void SerialPuts(int fd, string s);
-
- ///
- /// Returns the number of characters available for reading, or -1 for any error condition,
- /// in which case errno will be set appropriately.
- ///
- /// The fd.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "serialDataAvail", SetLastError = true)]
- public static extern int SerialDataAvail(int fd);
-
- ///
- /// Returns the next character available on the serial device.
- /// This call will block for up to 10 seconds if no data is available (when it will return -1).
- ///
- /// The fd.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "serialGetchar", SetLastError = true)]
- public static extern int SerialGetchar(int fd);
-
- ///
- /// This discards all data received, or waiting to be send down the given device.
- ///
- /// The fd.
- [DllImport(WiringPiLibrary, EntryPoint = "serialFlush", SetLastError = true)]
- public static extern void SerialFlush(int fd);
- }
+using System;
+using System.Runtime.InteropServices;
+
+namespace Unosquare.WiringPi.Native {
+ public partial class WiringPi {
+ ///
+ /// This opens and initialises the serial device and sets the baud rate. It sets the port into “raw” mode (character at a time and no translations),
+ /// and sets the read timeout to 10 seconds. The return value is the file descriptor or -1 for any error, in which case errno will be set as appropriate.
+ /// The wiringSerial library is intended to provide simplified control – suitable for most applications, however if you need advanced control
+ /// – e.g. parity control, modem control lines (via a USB adapter, there are none on the Pi’s on-board UART!) and so on,
+ /// then you need to do some of this the old fashioned way.
+ ///
+ /// The device.
+ /// The baud.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialOpen", SetLastError = true)]
+ public static extern Int32 SerialOpen(String device, Int32 baud);
+
+ ///
+ /// Closes the device identified by the file descriptor given.
+ ///
+ /// The fd.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialClose", SetLastError = true)]
+ public static extern Int32 SerialClose(Int32 fd);
+
+ ///
+ /// Sends the single byte to the serial device identified by the given file descriptor.
+ ///
+ /// The fd.
+ /// The c.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialPutchar", SetLastError = true)]
+ public static extern void SerialPutchar(Int32 fd, Byte c);
+
+ ///
+ /// Sends the nul-terminated string to the serial device identified by the given file descriptor.
+ ///
+ /// The fd.
+ /// The s.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialPuts", SetLastError = true)]
+ public static extern void SerialPuts(Int32 fd, String s);
+
+ ///
+ /// Returns the number of characters available for reading, or -1 for any error condition,
+ /// in which case errno will be set appropriately.
+ ///
+ /// The fd.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialDataAvail", SetLastError = true)]
+ public static extern Int32 SerialDataAvail(Int32 fd);
+
+ ///
+ /// Returns the next character available on the serial device.
+ /// This call will block for up to 10 seconds if no data is available (when it will return -1).
+ ///
+ /// The fd.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialGetchar", SetLastError = true)]
+ public static extern Int32 SerialGetchar(Int32 fd);
+
+ ///
+ /// This discards all data received, or waiting to be send down the given device.
+ ///
+ /// The fd.
+ [DllImport(WiringPiLibrary, EntryPoint = "serialFlush", SetLastError = true)]
+ public static extern void SerialFlush(Int32 fd);
+ }
}
\ No newline at end of file
diff --git a/Unosquare.WiringPi/Native/WiringPi.Shift.cs b/Unosquare.WiringPi/Native/WiringPi.Shift.cs
index 80cc913..d1912f0 100644
--- a/Unosquare.WiringPi/Native/WiringPi.Shift.cs
+++ b/Unosquare.WiringPi/Native/WiringPi.Shift.cs
@@ -1,36 +1,35 @@
-namespace Unosquare.WiringPi.Native
-{
- using System.Runtime.InteropServices;
-
- public partial class WiringPi
- {
- #region WiringPi - Shift Library
-
- ///
- /// This shifts an 8-bit data value in with the data appearing on the dPin and the clock being sent out on the cPin.
- /// Order is either LSBFIRST or MSBFIRST. The data is sampled after the cPin goes high.
- /// (So cPin high, sample data, cPin low, repeat for 8 bits) The 8-bit value is returned by the function.
- ///
- /// The d pin.
- /// The c pin.
- /// The order.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "shiftIn", SetLastError = true)]
- public static extern byte ShiftIn(byte dPin, byte cPin, byte order);
-
- ///
- /// The shifts an 8-bit data value val out with the data being sent out on dPin and the clock being sent out on the cPin.
- /// order is as above. Data is clocked out on the rising or falling edge – ie. dPin is set, then cPin is taken high then low
- /// – repeated for the 8 bits.
- ///
- /// The d pin.
- /// The c pin.
- /// The order.
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "shiftOut", SetLastError = true)]
- public static extern void ShiftOut(byte dPin, byte cPin, byte order, byte val);
-
- #endregion
-
- }
+using System;
+using System.Runtime.InteropServices;
+
+namespace Unosquare.WiringPi.Native {
+ public partial class WiringPi {
+ #region WiringPi - Shift Library
+
+ ///
+ /// This shifts an 8-bit data value in with the data appearing on the dPin and the clock being sent out on the cPin.
+ /// Order is either LSBFIRST or MSBFIRST. The data is sampled after the cPin goes high.
+ /// (So cPin high, sample data, cPin low, repeat for 8 bits) The 8-bit value is returned by the function.
+ ///
+ /// The d pin.
+ /// The c pin.
+ /// The order.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "shiftIn", SetLastError = true)]
+ public static extern Byte ShiftIn(Byte dPin, Byte cPin, Byte order);
+
+ ///
+ /// The shifts an 8-bit data value val out with the data being sent out on dPin and the clock being sent out on the cPin.
+ /// order is as above. Data is clocked out on the rising or falling edge – ie. dPin is set, then cPin is taken high then low
+ /// – repeated for the 8 bits.
+ ///
+ /// The d pin.
+ /// The c pin.
+ /// The order.
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "shiftOut", SetLastError = true)]
+ public static extern void ShiftOut(Byte dPin, Byte cPin, Byte order, Byte val);
+
+ #endregion
+
+ }
}
diff --git a/Unosquare.WiringPi/Native/WiringPi.SoftPwm.cs b/Unosquare.WiringPi/Native/WiringPi.SoftPwm.cs
index b45bc26..a207ea8 100644
--- a/Unosquare.WiringPi/Native/WiringPi.SoftPwm.cs
+++ b/Unosquare.WiringPi/Native/WiringPi.SoftPwm.cs
@@ -1,64 +1,63 @@
-namespace Unosquare.WiringPi.Native
-{
- using System.Runtime.InteropServices;
-
- public partial class WiringPi
- {
- #region WiringPi - Soft PWM (https://github.com/WiringPi/WiringPi/blob/master/wiringPi/softPwm.h)
-
- ///
- /// This creates a software controlled PWM pin. You can use any GPIO pin and the pin numbering will be that of the wiringPiSetup()
- /// function you used. Use 100 for the pwmRange, then the value can be anything from 0 (off) to 100 (fully on) for the given pin.
- /// The return value is 0 for success. Anything else and you should check the global errno variable to see what went wrong.
- ///
- /// The pin.
- /// The initial value.
- /// The PWM range.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "softPwmCreate", SetLastError = true)]
- public static extern int SoftPwmCreate(int pin, int initialValue, int pwmRange);
-
- ///
- /// This updates the PWM value on the given pin. The value is checked to be in-range and pins that haven’t previously
- /// been initialized via softPwmCreate will be silently ignored.
- ///
- /// The pin.
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "softPwmWrite", SetLastError = true)]
- public static extern void SoftPwmWrite(int pin, int value);
-
- ///
- /// This function is undocumented.
- ///
- /// The pin.
- [DllImport(WiringPiLibrary, EntryPoint = "softPwmStop", SetLastError = true)]
- public static extern void SoftPwmStop(int pin);
-
- ///
- /// This creates a software controlled tone pin. You can use any GPIO pin and the pin numbering will be that of the wiringPiSetup() function you used.
- /// The return value is 0 for success. Anything else and you should check the global errno variable to see what went wrong.
- ///
- /// The pin.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "softToneCreate", SetLastError = true)]
- public static extern int SoftToneCreate(int pin);
-
- ///
- /// This function is undocumented.
- ///
- /// The pin.
- [DllImport(WiringPiLibrary, EntryPoint = "softToneStop", SetLastError = true)]
- public static extern void SoftToneStop(int pin);
-
- ///
- /// This updates the tone frequency value on the given pin. The tone will be played until you set the frequency to 0.
- ///
- /// The pin.
- /// The freq.
- [DllImport(WiringPiLibrary, EntryPoint = "softToneWrite", SetLastError = true)]
- public static extern void SoftToneWrite(int pin, int freq);
-
- #endregion
-
- }
+using System;
+using System.Runtime.InteropServices;
+
+namespace Unosquare.WiringPi.Native {
+ public partial class WiringPi {
+ #region WiringPi - Soft PWM (https://github.com/WiringPi/WiringPi/blob/master/wiringPi/softPwm.h)
+
+ ///
+ /// This creates a software controlled PWM pin. You can use any GPIO pin and the pin numbering will be that of the wiringPiSetup()
+ /// function you used. Use 100 for the pwmRange, then the value can be anything from 0 (off) to 100 (fully on) for the given pin.
+ /// The return value is 0 for success. Anything else and you should check the global errno variable to see what went wrong.
+ ///
+ /// The pin.
+ /// The initial value.
+ /// The PWM range.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "softPwmCreate", SetLastError = true)]
+ public static extern Int32 SoftPwmCreate(Int32 pin, Int32 initialValue, Int32 pwmRange);
+
+ ///
+ /// This updates the PWM value on the given pin. The value is checked to be in-range and pins that haven’t previously
+ /// been initialized via softPwmCreate will be silently ignored.
+ ///
+ /// The pin.
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "softPwmWrite", SetLastError = true)]
+ public static extern void SoftPwmWrite(Int32 pin, Int32 value);
+
+ ///
+ /// This function is undocumented.
+ ///
+ /// The pin.
+ [DllImport(WiringPiLibrary, EntryPoint = "softPwmStop", SetLastError = true)]
+ public static extern void SoftPwmStop(Int32 pin);
+
+ ///
+ /// This creates a software controlled tone pin. You can use any GPIO pin and the pin numbering will be that of the wiringPiSetup() function you used.
+ /// The return value is 0 for success. Anything else and you should check the global errno variable to see what went wrong.
+ ///
+ /// The pin.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "softToneCreate", SetLastError = true)]
+ public static extern Int32 SoftToneCreate(Int32 pin);
+
+ ///
+ /// This function is undocumented.
+ ///
+ /// The pin.
+ [DllImport(WiringPiLibrary, EntryPoint = "softToneStop", SetLastError = true)]
+ public static extern void SoftToneStop(Int32 pin);
+
+ ///
+ /// This updates the tone frequency value on the given pin. The tone will be played until you set the frequency to 0.
+ ///
+ /// The pin.
+ /// The freq.
+ [DllImport(WiringPiLibrary, EntryPoint = "softToneWrite", SetLastError = true)]
+ public static extern void SoftToneWrite(Int32 pin, Int32 freq);
+
+ #endregion
+
+ }
}
diff --git a/Unosquare.WiringPi/Native/WiringPi.Spi.cs b/Unosquare.WiringPi/Native/WiringPi.Spi.cs
index 6e1cab1..8e7e479 100644
--- a/Unosquare.WiringPi/Native/WiringPi.Spi.cs
+++ b/Unosquare.WiringPi/Native/WiringPi.Spi.cs
@@ -1,53 +1,52 @@
-namespace Unosquare.WiringPi.Native
-{
- using System.Runtime.InteropServices;
-
- public partial class WiringPi
- {
- #region WiringPi - SPI Library Calls
-
- ///
- /// This function is undocumented.
- ///
- /// The channel.
- /// Unknown.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPIGetFd", SetLastError = true)]
- public static extern int WiringPiSPIGetFd(int channel);
-
- ///
- /// This performs a simultaneous write/read transaction over the selected SPI bus. Data that was in your buffer is overwritten by data returned from the SPI bus.
- /// That’s all there is in the helper library. It is possible to do simple read and writes over the SPI bus using the standard read() and write() system calls though –
- /// write() may be better to use for sending data to chains of shift registers, or those LED strings where you send RGB triplets of data.
- /// Devices such as A/D and D/A converters usually need to perform a concurrent write/read transaction to work.
- ///
- /// The channel.
- /// The data.
- /// The length.
- /// The result.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPIDataRW", SetLastError = true)]
- public static extern int WiringPiSPIDataRW(int channel, byte[] data, int len);
-
- ///
- /// This function is undocumented.
- ///
- /// The channel.
- /// The speed.
- /// The mode.
- /// Unkown.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPISetupMode", SetLastError = true)]
- public static extern int WiringPiSPISetupMode(int channel, int speed, int mode);
-
- ///
- /// This is the way to initialize a channel (The Pi has 2 channels; 0 and 1). The speed parameter is an integer
- /// in the range 500,000 through 32,000,000 and represents the SPI clock speed in Hz.
- /// The returned value is the Linux file-descriptor for the device, or -1 on error. If an error has happened, you may use the standard errno global variable to see why.
- ///
- /// The channel.
- /// The speed.
- /// The Linux file descriptor for the device or -1 for error.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPISetup", SetLastError = true)]
- public static extern int WiringPiSPISetup(int channel, int speed);
-
- #endregion
- }
+using System;
+using System.Runtime.InteropServices;
+
+namespace Unosquare.WiringPi.Native {
+ public partial class WiringPi {
+ #region WiringPi - SPI Library Calls
+
+ ///
+ /// This function is undocumented.
+ ///
+ /// The channel.
+ /// Unknown.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPIGetFd", SetLastError = true)]
+ public static extern Int32 WiringPiSPIGetFd(Int32 channel);
+
+ ///
+ /// This performs a simultaneous write/read transaction over the selected SPI bus. Data that was in your buffer is overwritten by data returned from the SPI bus.
+ /// That’s all there is in the helper library. It is possible to do simple read and writes over the SPI bus using the standard read() and write() system calls though –
+ /// write() may be better to use for sending data to chains of shift registers, or those LED strings where you send RGB triplets of data.
+ /// Devices such as A/D and D/A converters usually need to perform a concurrent write/read transaction to work.
+ ///
+ /// The channel.
+ /// The data.
+ /// The length.
+ /// The result.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPIDataRW", SetLastError = true)]
+ public static extern Int32 WiringPiSPIDataRW(Int32 channel, Byte[] data, Int32 len);
+
+ ///
+ /// This function is undocumented.
+ ///
+ /// The channel.
+ /// The speed.
+ /// The mode.
+ /// Unkown.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPISetupMode", SetLastError = true)]
+ public static extern Int32 WiringPiSPISetupMode(Int32 channel, Int32 speed, Int32 mode);
+
+ ///
+ /// This is the way to initialize a channel (The Pi has 2 channels; 0 and 1). The speed parameter is an integer
+ /// in the range 500,000 through 32,000,000 and represents the SPI clock speed in Hz.
+ /// The returned value is the Linux file-descriptor for the device, or -1 on error. If an error has happened, you may use the standard errno global variable to see why.
+ ///
+ /// The channel.
+ /// The speed.
+ /// The Linux file descriptor for the device or -1 for error.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSPISetup", SetLastError = true)]
+ public static extern Int32 WiringPiSPISetup(Int32 channel, Int32 speed);
+
+ #endregion
+ }
}
diff --git a/Unosquare.WiringPi/Native/WiringPi.cs b/Unosquare.WiringPi/Native/WiringPi.cs
index 866f924..e2f06f7 100644
--- a/Unosquare.WiringPi/Native/WiringPi.cs
+++ b/Unosquare.WiringPi/Native/WiringPi.cs
@@ -1,376 +1,375 @@
-namespace Unosquare.WiringPi.Native
-{
- using System.Runtime.InteropServices;
-
+using System.Runtime.InteropServices;
+using System;
+
+namespace Unosquare.WiringPi.Native {
+ ///
+ /// Provides native C WiringPi Library function call wrappers
+ /// All credit for the native library goes to the author of http://wiringpi.com/
+ /// The wrappers were written based on https://github.com/WiringPi/WiringPi/blob/master/wiringPi/wiringPi.h.
+ ///
+ public partial class WiringPi {
+ internal const String WiringPiLibrary = "libwiringPi.so.2.50";
+
+ #region WiringPi - Core Functions (https://github.com/WiringPi/WiringPi/blob/master/wiringPi/wiringPi.h)
+
///
- /// Provides native C WiringPi Library function call wrappers
- /// All credit for the native library goes to the author of http://wiringpi.com/
- /// The wrappers were written based on https://github.com/WiringPi/WiringPi/blob/master/wiringPi/wiringPi.h.
+ /// This initialises wiringPi and assumes that the calling program is going to be using the wiringPi pin numbering scheme.
+ /// This is a simplified numbering scheme which provides a mapping from virtual pin numbers 0 through 16 to the real underlying Broadcom GPIO pin numbers.
+ /// See the pins page for a table which maps the wiringPi pin number to the Broadcom GPIO pin number to the physical location on the edge connector.
+ /// This function needs to be called with root privileges.
///
- public partial class WiringPi
- {
- internal const string WiringPiLibrary = "libwiringPi.so.2.50";
-
- #region WiringPi - Core Functions (https://github.com/WiringPi/WiringPi/blob/master/wiringPi/wiringPi.h)
-
- ///
- /// This initialises wiringPi and assumes that the calling program is going to be using the wiringPi pin numbering scheme.
- /// This is a simplified numbering scheme which provides a mapping from virtual pin numbers 0 through 16 to the real underlying Broadcom GPIO pin numbers.
- /// See the pins page for a table which maps the wiringPi pin number to the Broadcom GPIO pin number to the physical location on the edge connector.
- /// This function needs to be called with root privileges.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetup", SetLastError = true)]
- public static extern int WiringPiSetup();
-
- ///
- /// This initialises wiringPi but uses the /sys/class/gpio interface rather than accessing the hardware directly.
- /// This can be called as a non-root user provided the GPIO pins have been exported before-hand using the gpio program.
- /// Pin numbering in this mode is the native Broadcom GPIO numbers – the same as wiringPiSetupGpio() above,
- /// so be aware of the differences between Rev 1 and Rev 2 boards.
- ///
- /// Note: In this mode you can only use the pins which have been exported via the /sys/class/gpio interface before you run your program.
- /// You can do this in a separate shell-script, or by using the system() function from inside your program to call the gpio program.
- /// Also note that some functions have no effect when using this mode as they’re not currently possible to action unless called with root privileges.
- /// (although you can use system() to call gpio to set/change modes if needed).
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetupSys", SetLastError = true)]
- public static extern int WiringPiSetupSys();
-
- ///
- /// This is identical to wiringPiSetup, however it allows the calling programs to use the Broadcom GPIO
- /// pin numbers directly with no re-mapping.
- /// As above, this function needs to be called with root privileges, and note that some pins are different
- /// from revision 1 to revision 2 boards.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetupGpio", SetLastError = true)]
- public static extern int WiringPiSetupGpio();
-
- ///
- /// Identical to wiringPiSetup, however it allows the calling programs to use the physical pin numbers on the P1 connector only.
- /// This function needs to be called with root privileges.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetupPhys", SetLastError = true)]
- public static extern int WiringPiSetupPhys();
-
- ///
- /// This function is undocumented.
- ///
- /// The pin.
- /// The mode.
- [DllImport(WiringPiLibrary, EntryPoint = "pinModeAlt", SetLastError = true)]
- public static extern void PinModeAlt(int pin, int mode);
-
- ///
- /// This sets the mode of a pin to either INPUT, OUTPUT, PWM_OUTPUT or GPIO_CLOCK.
- /// Note that only wiringPi pin 1 (BCM_GPIO 18) supports PWM output and only wiringPi pin 7 (BCM_GPIO 4)
- /// supports CLOCK output modes.
- ///
- /// This function has no effect when in Sys mode. If you need to change the pin mode, then you can
- /// do it with the gpio program in a script before you start your program.
- ///
- /// The pin.
- /// The mode.
- [DllImport(WiringPiLibrary, EntryPoint = "pinMode", SetLastError = true)]
- public static extern void PinMode(int pin, int mode);
-
- ///
- /// This sets the pull-up or pull-down resistor mode on the given pin, which should be set as an input.
- /// Unlike the Arduino, the BCM2835 has both pull-up and down internal resistors. The parameter pud should be; PUD_OFF,
- /// (no pull up/down), PUD_DOWN (pull to ground) or PUD_UP (pull to 3.3v) The internal pull up/down resistors
- /// have a value of approximately 50KΩ on the Raspberry Pi.
- ///
- /// This function has no effect on the Raspberry Pi’s GPIO pins when in Sys mode.
- /// If you need to activate a pull-up/pull-down, then you can do it with the gpio program in a script before you start your program.
- ///
- /// The pin.
- /// The pud.
- [DllImport(WiringPiLibrary, EntryPoint = "pullUpDnControl", SetLastError = true)]
- public static extern void PullUpDnControl(int pin, int pud);
-
- ///
- /// This function returns the value read at the given pin. It will be HIGH or LOW (1 or 0) depending on the logic level at the pin.
- ///
- /// The pin.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "digitalRead", SetLastError = true)]
- public static extern int DigitalRead(int pin);
-
- ///
- /// Writes the value HIGH or LOW (1 or 0) to the given pin which must have been previously set as an output.
- /// WiringPi treats any non-zero number as HIGH, however 0 is the only representation of LOW.
- ///
- /// The pin.
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "digitalWrite", SetLastError = true)]
- public static extern void DigitalWrite(int pin, int value);
-
- ///
- /// Writes the value to the PWM register for the given pin. The Raspberry Pi has one
- /// on-board PWM pin, pin 1 (BMC_GPIO 18, Phys 12) and the range is 0-1024.
- /// Other PWM devices may have other PWM ranges.
- /// This function is not able to control the Pi’s on-board PWM when in Sys mode.
- ///
- /// The pin.
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "pwmWrite", SetLastError = true)]
- public static extern void PwmWrite(int pin, int value);
-
- ///
- /// This returns the value read on the supplied analog input pin. You will need to
- /// register additional analog modules to enable this function for devices such as the Gertboard, quick2Wire analog board, etc.
- ///
- /// The pin.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "analogRead", SetLastError = true)]
- public static extern int AnalogRead(int pin);
-
- ///
- /// This writes the given value to the supplied analog pin. You will need to register additional
- /// analog modules to enable this function for devices such as the Gertboard.
- ///
- /// The pin.
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "analogWrite", SetLastError = true)]
- public static extern void AnalogWrite(int pin, int value);
-
- ///
- /// This returns the board revision of the Raspberry Pi. It will be either 1 or 2. Some of the BCM_GPIO pins changed number and
- /// function when moving from board revision 1 to 2, so if you are using BCM_GPIO pin numbers, then you need to be aware of the differences.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "piBoardRev", SetLastError = true)]
- public static extern int PiBoardRev();
-
- ///
- /// This function is undocumented.
- ///
- /// The model.
- /// The memory.
- /// The maker.
- /// The over volted.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "piBoardId", SetLastError = true)]
- public static extern int PiBoardId(ref int model, ref int mem, ref int maker, ref int overVolted);
-
- ///
- /// This returns the BCM_GPIO pin number of the supplied wiringPi pin. It takes the board revision into account.
- ///
- /// The w pi pin.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "wpiPinToGpio", SetLastError = true)]
- public static extern int WpiPinToGpio(int wPiPin);
-
- ///
- /// This returns the BCM_GPIO pin number of the supplied physical pin on the P1 connector.
- ///
- /// The physical pin.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "physPinToGpio", SetLastError = true)]
- public static extern int PhysPinToGpio(int physPin);
-
- ///
- /// This sets the “strength” of the pad drivers for a particular group of pins.
- /// There are 3 groups of pins and the drive strength is from 0 to 7. Do not use this unless you know what you are doing.
- ///
- /// The group.
- /// The value.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "setPadDrive", SetLastError = true)]
- public static extern int SetPadDrive(int group, int value);
-
- ///
- /// Undocumented function.
- ///
- /// The pin.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "getAlt", SetLastError = true)]
- public static extern int GetAlt(int pin);
-
- ///
- /// Undocumented function.
- ///
- /// The pin.
- /// The freq.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "pwmToneWrite", SetLastError = true)]
- public static extern int PwmToneWrite(int pin, int freq);
-
- ///
- /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to set all 8 bits at once to a particular value, although it still takes two write operations to the Pi’s GPIO hardware.
- ///
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "digitalWriteByte", SetLastError = true)]
- public static extern void DigitalWriteByte(int value);
-
- ///
- /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to set all 8 bits at once to a particular value, although it still takes two write operations to the Pi’s GPIO hardware.
- ///
- /// The value.
- [DllImport(WiringPiLibrary, EntryPoint = "digitalWriteByte2", SetLastError = true)]
- public static extern void DigitalWriteByte2(int value);
-
- ///
- /// Undocumented function
- /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to get all 8 bits at once to a particular value.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "digitalReadByte", SetLastError = true)]
- public static extern uint DigitalReadByte();
-
- ///
- /// Undocumented function
- /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
- /// It’s the fastest way to get all 8 bits at once to a particular value.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "digitalReadByte2", SetLastError = true)]
- public static extern uint DigitalReadByte2();
-
- ///
- /// The PWM generator can run in 2 modes – “balanced” and “mark:space”. The mark:space mode is traditional,
- /// however the default mode in the Pi is “balanced”. You can switch modes by supplying the parameter: PWM_MODE_BAL or PWM_MODE_MS.
- ///
- /// The mode.
- [DllImport(WiringPiLibrary, EntryPoint = "pwmSetMode", SetLastError = true)]
- public static extern void PwmSetMode(int mode);
-
- ///
- /// This sets the range register in the PWM generator. The default is 1024.
- ///
- /// The range.
- [DllImport(WiringPiLibrary, EntryPoint = "pwmSetRange", SetLastError = true)]
- public static extern void PwmSetRange(uint range);
-
- ///
- /// This sets the divisor for the PWM clock.
- /// Note: The PWM control functions can not be used when in Sys mode.
- /// To understand more about the PWM system, you’ll need to read the Broadcom ARM peripherals manual.
- ///
- /// The divisor.
- [DllImport(WiringPiLibrary, EntryPoint = "pwmSetClock", SetLastError = true)]
- public static extern void PwmSetClock(int divisor);
-
- ///
- /// Undocumented function.
- ///
- /// The pin.
- /// The freq.
- [DllImport(WiringPiLibrary, EntryPoint = "gpioClockSet", SetLastError = true)]
- public static extern void GpioClockSet(int pin, int freq);
-
- ///
- /// This function registers a function to received interrupts on the specified pin.
- /// The edgeType parameter is either INT_EDGE_FALLING, INT_EDGE_RISING, INT_EDGE_BOTH or INT_EDGE_SETUP.
- /// If it is INT_EDGE_SETUP then no initialisation of the pin will happen – it’s assumed that you have already setup the pin elsewhere
- /// (e.g. with the gpio program), but if you specify one of the other types, then the pin will be exported and initialised as specified.
- /// This is accomplished via a suitable call to the gpio utility program, so it need to be available.
- /// The pin number is supplied in the current mode – native wiringPi, BCM_GPIO, physical or Sys modes.
- /// This function will work in any mode, and does not need root privileges to work.
- /// The function will be called when the interrupt triggers. When it is triggered, it’s cleared in the dispatcher before calling your function,
- /// so if a subsequent interrupt fires before you finish your handler, then it won’t be missed. (However it can only track one more interrupt,
- /// if more than one interrupt fires while one is being handled then they will be ignored)
- /// This function is run at a high priority (if the program is run using sudo, or as root) and executes concurrently with the main program.
- /// It has full access to all the global variables, open file handles and so on.
- ///
- /// The pin.
- /// The mode.
- /// The method.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "wiringPiISR", SetLastError = true)]
- public static extern int WiringPiISR(int pin, int mode, InterruptServiceRoutineCallback method);
-
- ///
- /// This function creates a thread which is another function in your program previously declared using the PI_THREAD declaration.
- /// This function is then run concurrently with your main program. An example may be to have this function wait for an interrupt while
- /// your program carries on doing other tasks. The thread can indicate an event, or action by using global variables to
- /// communicate back to the main program, or other threads.
- ///
- /// The method.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "piThreadCreate", SetLastError = true)]
- public static extern int PiThreadCreate(ThreadWorker method);
-
- ///
- /// These allow you to synchronise variable updates from your main program to any threads running in your program. keyNum is a number from 0 to 3 and represents a key.
- /// When another process tries to lock the same key, it will be stalled until the first process has unlocked the same key.
- /// You may need to use these functions to ensure that you get valid data when exchanging data between your main program and a thread
- /// – otherwise it’s possible that the thread could wake-up halfway during your data copy and change the data –
- /// so the data you end up copying is incomplete, or invalid. See the wfi.c program in the examples directory for an example.
- ///
- /// The key.
- [DllImport(WiringPiLibrary, EntryPoint = "piLock", SetLastError = true)]
- public static extern void PiLock(int key);
-
- ///
- /// These allow you to synchronise variable updates from your main program to any threads running in your program. keyNum is a number from 0 to 3 and represents a key.
- /// When another process tries to lock the same key, it will be stalled until the first process has unlocked the same key.
- /// You may need to use these functions to ensure that you get valid data when exchanging data between your main program and a thread
- /// – otherwise it’s possible that the thread could wake-up halfway during your data copy and change the data –
- /// so the data you end up copying is incomplete, or invalid. See the wfi.c program in the examples directory for an example.
- ///
- /// The key.
- [DllImport(WiringPiLibrary, EntryPoint = "piUnlock", SetLastError = true)]
- public static extern void PiUnlock(int key);
-
- ///
- /// This attempts to shift your program (or thread in a multi-threaded program) to a higher priority
- /// and enables a real-time scheduling. The priority parameter should be from 0 (the default) to 99 (the maximum).
- /// This won’t make your program go any faster, but it will give it a bigger slice of time when other programs are running.
- /// The priority parameter works relative to others – so you can make one program priority 1 and another priority 2
- /// and it will have the same effect as setting one to 10 and the other to 90 (as long as no other
- /// programs are running with elevated priorities)
- /// The return value is 0 for success and -1 for error. If an error is returned, the program should then consult the errno global variable, as per the usual conventions.
- /// Note: Only programs running as root can change their priority. If called from a non-root program then nothing happens.
- ///
- /// The priority.
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "piHiPri", SetLastError = true)]
- public static extern int PiHiPri(int priority);
-
- ///
- /// This causes program execution to pause for at least howLong milliseconds.
- /// Due to the multi-tasking nature of Linux it could be longer.
- /// Note that the maximum delay is an unsigned 32-bit integer or approximately 49 days.
- ///
- /// The how long.
- [DllImport(WiringPiLibrary, EntryPoint = "delay", SetLastError = true)]
- public static extern void Delay(uint howLong);
-
- ///
- /// This causes program execution to pause for at least howLong microseconds.
- /// Due to the multi-tasking nature of Linux it could be longer.
- /// Note that the maximum delay is an unsigned 32-bit integer microseconds or approximately 71 minutes.
- /// Delays under 100 microseconds are timed using a hard-coded loop continually polling the system time,
- /// Delays over 100 microseconds are done using the system nanosleep() function – You may need to consider the implications
- /// of very short delays on the overall performance of the system, especially if using threads.
- ///
- /// The how long.
- [DllImport(WiringPiLibrary, EntryPoint = "delayMicroseconds", SetLastError = true)]
- public static extern void DelayMicroseconds(uint howLong);
-
- ///
- /// This returns a number representing the number of milliseconds since your program called one of the wiringPiSetup functions.
- /// It returns an unsigned 32-bit number which wraps after 49 days.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "millis", SetLastError = true)]
- public static extern uint Millis();
-
- ///
- /// This returns a number representing the number of microseconds since your program called one of
- /// the wiringPiSetup functions. It returns an unsigned 32-bit number which wraps after approximately 71 minutes.
- ///
- /// The result code.
- [DllImport(WiringPiLibrary, EntryPoint = "micros", SetLastError = true)]
- public static extern uint Micros();
-
- #endregion
- }
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetup", SetLastError = true)]
+ public static extern Int32 WiringPiSetup();
+
+ ///
+ /// This initialises wiringPi but uses the /sys/class/gpio interface rather than accessing the hardware directly.
+ /// This can be called as a non-root user provided the GPIO pins have been exported before-hand using the gpio program.
+ /// Pin numbering in this mode is the native Broadcom GPIO numbers – the same as wiringPiSetupGpio() above,
+ /// so be aware of the differences between Rev 1 and Rev 2 boards.
+ ///
+ /// Note: In this mode you can only use the pins which have been exported via the /sys/class/gpio interface before you run your program.
+ /// You can do this in a separate shell-script, or by using the system() function from inside your program to call the gpio program.
+ /// Also note that some functions have no effect when using this mode as they’re not currently possible to action unless called with root privileges.
+ /// (although you can use system() to call gpio to set/change modes if needed).
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetupSys", SetLastError = true)]
+ public static extern Int32 WiringPiSetupSys();
+
+ ///
+ /// This is identical to wiringPiSetup, however it allows the calling programs to use the Broadcom GPIO
+ /// pin numbers directly with no re-mapping.
+ /// As above, this function needs to be called with root privileges, and note that some pins are different
+ /// from revision 1 to revision 2 boards.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetupGpio", SetLastError = true)]
+ public static extern Int32 WiringPiSetupGpio();
+
+ ///
+ /// Identical to wiringPiSetup, however it allows the calling programs to use the physical pin numbers on the P1 connector only.
+ /// This function needs to be called with root privileges.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiSetupPhys", SetLastError = true)]
+ public static extern Int32 WiringPiSetupPhys();
+
+ ///
+ /// This function is undocumented.
+ ///
+ /// The pin.
+ /// The mode.
+ [DllImport(WiringPiLibrary, EntryPoint = "pinModeAlt", SetLastError = true)]
+ public static extern void PinModeAlt(Int32 pin, Int32 mode);
+
+ ///
+ /// This sets the mode of a pin to either INPUT, OUTPUT, PWM_OUTPUT or GPIO_CLOCK.
+ /// Note that only wiringPi pin 1 (BCM_GPIO 18) supports PWM output and only wiringPi pin 7 (BCM_GPIO 4)
+ /// supports CLOCK output modes.
+ ///
+ /// This function has no effect when in Sys mode. If you need to change the pin mode, then you can
+ /// do it with the gpio program in a script before you start your program.
+ ///
+ /// The pin.
+ /// The mode.
+ [DllImport(WiringPiLibrary, EntryPoint = "pinMode", SetLastError = true)]
+ public static extern void PinMode(Int32 pin, Int32 mode);
+
+ ///
+ /// This sets the pull-up or pull-down resistor mode on the given pin, which should be set as an input.
+ /// Unlike the Arduino, the BCM2835 has both pull-up and down internal resistors. The parameter pud should be; PUD_OFF,
+ /// (no pull up/down), PUD_DOWN (pull to ground) or PUD_UP (pull to 3.3v) The internal pull up/down resistors
+ /// have a value of approximately 50KΩ on the Raspberry Pi.
+ ///
+ /// This function has no effect on the Raspberry Pi’s GPIO pins when in Sys mode.
+ /// If you need to activate a pull-up/pull-down, then you can do it with the gpio program in a script before you start your program.
+ ///
+ /// The pin.
+ /// The pud.
+ [DllImport(WiringPiLibrary, EntryPoint = "pullUpDnControl", SetLastError = true)]
+ public static extern void PullUpDnControl(Int32 pin, Int32 pud);
+
+ ///
+ /// This function returns the value read at the given pin. It will be HIGH or LOW (1 or 0) depending on the logic level at the pin.
+ ///
+ /// The pin.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "digitalRead", SetLastError = true)]
+ public static extern Int32 DigitalRead(Int32 pin);
+
+ ///
+ /// Writes the value HIGH or LOW (1 or 0) to the given pin which must have been previously set as an output.
+ /// WiringPi treats any non-zero number as HIGH, however 0 is the only representation of LOW.
+ ///
+ /// The pin.
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "digitalWrite", SetLastError = true)]
+ public static extern void DigitalWrite(Int32 pin, Int32 value);
+
+ ///
+ /// Writes the value to the PWM register for the given pin. The Raspberry Pi has one
+ /// on-board PWM pin, pin 1 (BMC_GPIO 18, Phys 12) and the range is 0-1024.
+ /// Other PWM devices may have other PWM ranges.
+ /// This function is not able to control the Pi’s on-board PWM when in Sys mode.
+ ///
+ /// The pin.
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "pwmWrite", SetLastError = true)]
+ public static extern void PwmWrite(Int32 pin, Int32 value);
+
+ ///
+ /// This returns the value read on the supplied analog input pin. You will need to
+ /// register additional analog modules to enable this function for devices such as the Gertboard, quick2Wire analog board, etc.
+ ///
+ /// The pin.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "analogRead", SetLastError = true)]
+ public static extern Int32 AnalogRead(Int32 pin);
+
+ ///
+ /// This writes the given value to the supplied analog pin. You will need to register additional
+ /// analog modules to enable this function for devices such as the Gertboard.
+ ///
+ /// The pin.
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "analogWrite", SetLastError = true)]
+ public static extern void AnalogWrite(Int32 pin, Int32 value);
+
+ ///
+ /// This returns the board revision of the Raspberry Pi. It will be either 1 or 2. Some of the BCM_GPIO pins changed number and
+ /// function when moving from board revision 1 to 2, so if you are using BCM_GPIO pin numbers, then you need to be aware of the differences.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "piBoardRev", SetLastError = true)]
+ public static extern Int32 PiBoardRev();
+
+ ///
+ /// This function is undocumented.
+ ///
+ /// The model.
+ /// The memory.
+ /// The maker.
+ /// The over volted.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "piBoardId", SetLastError = true)]
+ public static extern Int32 PiBoardId(ref Int32 model, ref Int32 mem, ref Int32 maker, ref Int32 overVolted);
+
+ ///
+ /// This returns the BCM_GPIO pin number of the supplied wiringPi pin. It takes the board revision into account.
+ ///
+ /// The w pi pin.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "wpiPinToGpio", SetLastError = true)]
+ public static extern Int32 WpiPinToGpio(Int32 wPiPin);
+
+ ///
+ /// This returns the BCM_GPIO pin number of the supplied physical pin on the P1 connector.
+ ///
+ /// The physical pin.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "physPinToGpio", SetLastError = true)]
+ public static extern Int32 PhysPinToGpio(Int32 physPin);
+
+ ///
+ /// This sets the “strength” of the pad drivers for a particular group of pins.
+ /// There are 3 groups of pins and the drive strength is from 0 to 7. Do not use this unless you know what you are doing.
+ ///
+ /// The group.
+ /// The value.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "setPadDrive", SetLastError = true)]
+ public static extern Int32 SetPadDrive(Int32 group, Int32 value);
+
+ ///
+ /// Undocumented function.
+ ///
+ /// The pin.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "getAlt", SetLastError = true)]
+ public static extern Int32 GetAlt(Int32 pin);
+
+ ///
+ /// Undocumented function.
+ ///
+ /// The pin.
+ /// The freq.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "pwmToneWrite", SetLastError = true)]
+ public static extern Int32 PwmToneWrite(Int32 pin, Int32 freq);
+
+ ///
+ /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to set all 8 bits at once to a particular value, although it still takes two write operations to the Pi’s GPIO hardware.
+ ///
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "digitalWriteByte", SetLastError = true)]
+ public static extern void DigitalWriteByte(Int32 value);
+
+ ///
+ /// This writes the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to set all 8 bits at once to a particular value, although it still takes two write operations to the Pi’s GPIO hardware.
+ ///
+ /// The value.
+ [DllImport(WiringPiLibrary, EntryPoint = "digitalWriteByte2", SetLastError = true)]
+ public static extern void DigitalWriteByte2(Int32 value);
+
+ ///
+ /// Undocumented function
+ /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to get all 8 bits at once to a particular value.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "digitalReadByte", SetLastError = true)]
+ public static extern UInt32 DigitalReadByte();
+
+ ///
+ /// Undocumented function
+ /// This reads the 8-bit byte supplied to the first 8 GPIO pins.
+ /// It’s the fastest way to get all 8 bits at once to a particular value.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "digitalReadByte2", SetLastError = true)]
+ public static extern UInt32 DigitalReadByte2();
+
+ ///
+ /// The PWM generator can run in 2 modes – “balanced” and “mark:space”. The mark:space mode is traditional,
+ /// however the default mode in the Pi is “balanced”. You can switch modes by supplying the parameter: PWM_MODE_BAL or PWM_MODE_MS.
+ ///
+ /// The mode.
+ [DllImport(WiringPiLibrary, EntryPoint = "pwmSetMode", SetLastError = true)]
+ public static extern void PwmSetMode(Int32 mode);
+
+ ///
+ /// This sets the range register in the PWM generator. The default is 1024.
+ ///
+ /// The range.
+ [DllImport(WiringPiLibrary, EntryPoint = "pwmSetRange", SetLastError = true)]
+ public static extern void PwmSetRange(UInt32 range);
+
+ ///
+ /// This sets the divisor for the PWM clock.
+ /// Note: The PWM control functions can not be used when in Sys mode.
+ /// To understand more about the PWM system, you’ll need to read the Broadcom ARM peripherals manual.
+ ///
+ /// The divisor.
+ [DllImport(WiringPiLibrary, EntryPoint = "pwmSetClock", SetLastError = true)]
+ public static extern void PwmSetClock(Int32 divisor);
+
+ ///
+ /// Undocumented function.
+ ///
+ /// The pin.
+ /// The freq.
+ [DllImport(WiringPiLibrary, EntryPoint = "gpioClockSet", SetLastError = true)]
+ public static extern void GpioClockSet(Int32 pin, Int32 freq);
+
+ ///
+ /// This function registers a function to received interrupts on the specified pin.
+ /// The edgeType parameter is either INT_EDGE_FALLING, INT_EDGE_RISING, INT_EDGE_BOTH or INT_EDGE_SETUP.
+ /// If it is INT_EDGE_SETUP then no initialisation of the pin will happen – it’s assumed that you have already setup the pin elsewhere
+ /// (e.g. with the gpio program), but if you specify one of the other types, then the pin will be exported and initialised as specified.
+ /// This is accomplished via a suitable call to the gpio utility program, so it need to be available.
+ /// The pin number is supplied in the current mode – native wiringPi, BCM_GPIO, physical or Sys modes.
+ /// This function will work in any mode, and does not need root privileges to work.
+ /// The function will be called when the interrupt triggers. When it is triggered, it’s cleared in the dispatcher before calling your function,
+ /// so if a subsequent interrupt fires before you finish your handler, then it won’t be missed. (However it can only track one more interrupt,
+ /// if more than one interrupt fires while one is being handled then they will be ignored)
+ /// This function is run at a high priority (if the program is run using sudo, or as root) and executes concurrently with the main program.
+ /// It has full access to all the global variables, open file handles and so on.
+ ///
+ /// The pin.
+ /// The mode.
+ /// The method.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "wiringPiISR", SetLastError = true)]
+ public static extern Int32 WiringPiISR(Int32 pin, Int32 mode, InterruptServiceRoutineCallback method);
+
+ ///
+ /// This function creates a thread which is another function in your program previously declared using the PI_THREAD declaration.
+ /// This function is then run concurrently with your main program. An example may be to have this function wait for an interrupt while
+ /// your program carries on doing other tasks. The thread can indicate an event, or action by using global variables to
+ /// communicate back to the main program, or other threads.
+ ///
+ /// The method.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "piThreadCreate", SetLastError = true)]
+ public static extern Int32 PiThreadCreate(ThreadWorker method);
+
+ ///
+ /// These allow you to synchronise variable updates from your main program to any threads running in your program. keyNum is a number from 0 to 3 and represents a key.
+ /// When another process tries to lock the same key, it will be stalled until the first process has unlocked the same key.
+ /// You may need to use these functions to ensure that you get valid data when exchanging data between your main program and a thread
+ /// – otherwise it’s possible that the thread could wake-up halfway during your data copy and change the data –
+ /// so the data you end up copying is incomplete, or invalid. See the wfi.c program in the examples directory for an example.
+ ///
+ /// The key.
+ [DllImport(WiringPiLibrary, EntryPoint = "piLock", SetLastError = true)]
+ public static extern void PiLock(Int32 key);
+
+ ///
+ /// These allow you to synchronise variable updates from your main program to any threads running in your program. keyNum is a number from 0 to 3 and represents a key.
+ /// When another process tries to lock the same key, it will be stalled until the first process has unlocked the same key.
+ /// You may need to use these functions to ensure that you get valid data when exchanging data between your main program and a thread
+ /// – otherwise it’s possible that the thread could wake-up halfway during your data copy and change the data –
+ /// so the data you end up copying is incomplete, or invalid. See the wfi.c program in the examples directory for an example.
+ ///
+ /// The key.
+ [DllImport(WiringPiLibrary, EntryPoint = "piUnlock", SetLastError = true)]
+ public static extern void PiUnlock(Int32 key);
+
+ ///
+ /// This attempts to shift your program (or thread in a multi-threaded program) to a higher priority
+ /// and enables a real-time scheduling. The priority parameter should be from 0 (the default) to 99 (the maximum).
+ /// This won’t make your program go any faster, but it will give it a bigger slice of time when other programs are running.
+ /// The priority parameter works relative to others – so you can make one program priority 1 and another priority 2
+ /// and it will have the same effect as setting one to 10 and the other to 90 (as long as no other
+ /// programs are running with elevated priorities)
+ /// The return value is 0 for success and -1 for error. If an error is returned, the program should then consult the errno global variable, as per the usual conventions.
+ /// Note: Only programs running as root can change their priority. If called from a non-root program then nothing happens.
+ ///
+ /// The priority.
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "piHiPri", SetLastError = true)]
+ public static extern Int32 PiHiPri(Int32 priority);
+
+ ///
+ /// This causes program execution to pause for at least howLong milliseconds.
+ /// Due to the multi-tasking nature of Linux it could be longer.
+ /// Note that the maximum delay is an unsigned 32-bit integer or approximately 49 days.
+ ///
+ /// The how long.
+ [DllImport(WiringPiLibrary, EntryPoint = "delay", SetLastError = true)]
+ public static extern void Delay(UInt32 howLong);
+
+ ///
+ /// This causes program execution to pause for at least howLong microseconds.
+ /// Due to the multi-tasking nature of Linux it could be longer.
+ /// Note that the maximum delay is an unsigned 32-bit integer microseconds or approximately 71 minutes.
+ /// Delays under 100 microseconds are timed using a hard-coded loop continually polling the system time,
+ /// Delays over 100 microseconds are done using the system nanosleep() function – You may need to consider the implications
+ /// of very short delays on the overall performance of the system, especially if using threads.
+ ///
+ /// The how long.
+ [DllImport(WiringPiLibrary, EntryPoint = "delayMicroseconds", SetLastError = true)]
+ public static extern void DelayMicroseconds(UInt32 howLong);
+
+ ///
+ /// This returns a number representing the number of milliseconds since your program called one of the wiringPiSetup functions.
+ /// It returns an unsigned 32-bit number which wraps after 49 days.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "millis", SetLastError = true)]
+ public static extern UInt32 Millis();
+
+ ///
+ /// This returns a number representing the number of microseconds since your program called one of
+ /// the wiringPiSetup functions. It returns an unsigned 32-bit number which wraps after approximately 71 minutes.
+ ///
+ /// The result code.
+ [DllImport(WiringPiLibrary, EntryPoint = "micros", SetLastError = true)]
+ public static extern UInt32 Micros();
+
+ #endregion
+ }
}
\ No newline at end of file
diff --git a/Unosquare.WiringPi/Resources/EmbeddedResources.cs b/Unosquare.WiringPi/Resources/EmbeddedResources.cs
index efd28eb..0749aef 100644
--- a/Unosquare.WiringPi/Resources/EmbeddedResources.cs
+++ b/Unosquare.WiringPi/Resources/EmbeddedResources.cs
@@ -1,65 +1,56 @@
-namespace Unosquare.WiringPi.Resources
-{
- using Native;
- using System;
- using System.Collections.ObjectModel;
- using System.IO;
- using System.Reflection;
-
+using System;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Reflection;
+
+using Unosquare.WiringPi.Native;
+
+namespace Unosquare.WiringPi.Resources {
+ ///
+ /// Provides access to embedded assembly files.
+ ///
+ internal static class EmbeddedResources {
///
- /// Provides access to embedded assembly files.
+ /// Initializes static members of the class.
///
- internal static class EmbeddedResources
- {
- ///
- /// Initializes static members of the class.
- ///
- static EmbeddedResources()
- {
- ResourceNames =
- new ReadOnlyCollection(typeof(EmbeddedResources).Assembly.GetManifestResourceNames());
- }
-
- ///
- /// Gets the resource names.
- ///
- ///
- /// The resource names.
- ///
- public static ReadOnlyCollection ResourceNames { get; }
-
- ///
- /// Extracts all the file resources to the specified base path.
- ///
- public static void ExtractAll()
- {
- var basePath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
- var executablePermissions = SysCall.StringToInteger("0777", IntPtr.Zero, 8);
-
- foreach (var resourceName in ResourceNames)
- {
- var filename = resourceName.Substring($"{typeof(EmbeddedResources).Namespace}.".Length);
- var targetPath = Path.Combine(basePath, filename);
- if (File.Exists(targetPath)) return;
-
- using (var stream = typeof(EmbeddedResources).Assembly
- .GetManifestResourceStream(resourceName))
- {
- using (var outputStream = File.OpenWrite(targetPath))
- {
- stream?.CopyTo(outputStream);
- }
-
- try
- {
- SysCall.Chmod(targetPath, (uint)executablePermissions);
- }
- catch
- {
- /* Ignore */
- }
- }
- }
- }
- }
+ static EmbeddedResources() => ResourceNames = new ReadOnlyCollection(typeof(EmbeddedResources).Assembly.GetManifestResourceNames());
+
+ ///
+ /// Gets the resource names.
+ ///
+ ///
+ /// The resource names.
+ ///
+ public static ReadOnlyCollection ResourceNames {
+ get;
+ }
+
+ ///
+ /// Extracts all the file resources to the specified base path.
+ ///
+ public static void ExtractAll() {
+ String basePath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
+ Int32 executablePermissions = SysCall.StringToInteger("0777", IntPtr.Zero, 8);
+
+ foreach(String resourceName in ResourceNames) {
+ String filename = resourceName.Substring($"{typeof(EmbeddedResources).Namespace}.".Length);
+ String targetPath = Path.Combine(basePath, filename);
+ if(File.Exists(targetPath)) {
+ return;
+ }
+
+ using(Stream stream = typeof(EmbeddedResources).Assembly.GetManifestResourceStream(resourceName)) {
+ using(FileStream outputStream = File.OpenWrite(targetPath)) {
+ stream?.CopyTo(outputStream);
+ }
+
+ try {
+ _ = SysCall.Chmod(targetPath, (UInt32)executablePermissions);
+ } catch {
+ /* Ignore */
+ }
+ }
+ }
+ }
+ }
}
\ No newline at end of file
diff --git a/Unosquare.WiringPi/SpiBus.cs b/Unosquare.WiringPi/SpiBus.cs
index cecb167..19a0f95 100644
--- a/Unosquare.WiringPi/SpiBus.cs
+++ b/Unosquare.WiringPi/SpiBus.cs
@@ -1,43 +1,45 @@
-namespace Unosquare.WiringPi
-{
- using RaspberryIO.Abstractions;
-
- ///
- /// The SPI Bus containing the 2 SPI channels.
- ///
- public class SpiBus : ISpiBus
- {
- ///
- public int Channel0Frequency { get; set; }
-
- ///
- public int Channel1Frequency { get; set; }
-
- ///
- public int DefaultFrequency => 8000000;
-
- ///
- public ISpiChannel Channel0
- {
- get
- {
- if (Channel0Frequency == 0)
- Channel0Frequency = DefaultFrequency;
-
- return SpiChannel.Retrieve(SpiChannelNumber.Channel0, Channel0Frequency);
- }
- }
-
- ///
- public ISpiChannel Channel1
- {
- get
- {
- if (Channel1Frequency == 0)
- Channel1Frequency = DefaultFrequency;
-
- return SpiChannel.Retrieve(SpiChannelNumber.Channel1, Channel1Frequency);
- }
- }
- }
+using System;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// The SPI Bus containing the 2 SPI channels.
+ ///
+ public class SpiBus : ISpiBus {
+ ///
+ public Int32 Channel0Frequency {
+ get; set;
+ }
+
+ ///
+ public Int32 Channel1Frequency {
+ get; set;
+ }
+
+ ///
+ public Int32 DefaultFrequency => 8000000;
+
+ ///
+ public ISpiChannel Channel0 {
+ get {
+ if(this.Channel0Frequency == 0) {
+ this.Channel0Frequency = this.DefaultFrequency;
+ }
+
+ return SpiChannel.Retrieve(SpiChannelNumber.Channel0, this.Channel0Frequency);
+ }
+ }
+
+ ///
+ public ISpiChannel Channel1 {
+ get {
+ if(this.Channel1Frequency == 0) {
+ this.Channel1Frequency = this.DefaultFrequency;
+ }
+
+ return SpiChannel.Retrieve(SpiChannelNumber.Channel1, this.Channel1Frequency);
+ }
+ }
+ }
}
diff --git a/Unosquare.WiringPi/SpiChannel.cs b/Unosquare.WiringPi/SpiChannel.cs
index b85f01d..4c9c507 100644
--- a/Unosquare.WiringPi/SpiChannel.cs
+++ b/Unosquare.WiringPi/SpiChannel.cs
@@ -1,130 +1,131 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
- using RaspberryIO.Abstractions.Native;
- using Swan;
- using System;
- using System.Collections.Generic;
- using System.Threading.Tasks;
-
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+using Swan;
+
+using Unosquare.RaspberryIO.Abstractions;
+using Unosquare.RaspberryIO.Abstractions.Native;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Provides access to using the SPI buses on the GPIO.
+ /// SPI is a bus that works like a ring shift register
+ /// The number of bytes pushed is equal to the number of bytes received.
+ ///
+ public sealed class SpiChannel : ISpiChannel {
///
- /// Provides access to using the SPI buses on the GPIO.
- /// SPI is a bus that works like a ring shift register
- /// The number of bytes pushed is equal to the number of bytes received.
+ /// The minimum frequency of a SPI Channel.
///
- public sealed class SpiChannel : ISpiChannel
- {
- ///
- /// The minimum frequency of a SPI Channel.
- ///
- public const int MinFrequency = 500000;
-
- ///
- /// The maximum frequency of a SPI channel.
- ///
- public const int MaxFrequency = 32000000;
-
- private static readonly object SyncRoot = new object();
- private static readonly Dictionary Buses = new Dictionary();
- private readonly object _syncLock = new object();
-
- ///
- /// Initializes a new instance of the class.
- ///
- /// The channel.
- /// The frequency.
- private SpiChannel(SpiChannelNumber channel, int frequency)
- {
- lock (SyncRoot)
- {
- Frequency = frequency.Clamp(MinFrequency, MaxFrequency);
- Channel = (int)channel;
- FileDescriptor = WiringPi.WiringPiSPISetup((int)channel, Frequency);
-
- if (FileDescriptor < 0)
- {
- HardwareException.Throw(nameof(SpiChannel), channel.ToString());
- }
- }
- }
-
- ///
- public int FileDescriptor { get; }
-
- ///
- public int Channel { get; }
-
- ///
- public int Frequency { get; }
-
- ///
- public byte[] SendReceive(byte[] buffer)
- {
- if (buffer == null || buffer.Length == 0)
- return null;
-
- lock (_syncLock)
- {
- var spiBuffer = new byte[buffer.Length];
- Array.Copy(buffer, spiBuffer, buffer.Length);
-
- var result = WiringPi.WiringPiSPIDataRW(Channel, spiBuffer, spiBuffer.Length);
- if (result < 0) HardwareException.Throw(nameof(SpiChannel), nameof(SendReceive));
-
- return spiBuffer;
- }
- }
-
- ///
- /// Sends data and simultaneously receives the data in the return buffer.
- ///
- /// The buffer.
- ///
- /// The read bytes from the ring-style bus.
- ///
- public Task SendReceiveAsync(byte[] buffer) => Task.Run(() => SendReceive(buffer));
-
- ///
- public void Write(byte[] buffer)
- {
- lock (_syncLock)
- {
- var result = SysCall.Write(FileDescriptor, buffer, buffer.Length);
-
- if (result < 0)
- HardwareException.Throw(nameof(SpiChannel), nameof(Write));
- }
- }
-
- ///
- /// Writes the specified buffer the the underlying FileDescriptor.
- /// Do not use this method if you expect data back.
- /// This method is efficient if used in a fire-and-forget scenario
- /// like sending data over to those long RGB LED strips.
- ///
- /// The buffer.
- /// The awaitable task.
- public Task WriteAsync(byte[] buffer) => Task.Run(() => { Write(buffer); });
-
- ///
- /// Retrieves the spi bus. If the bus channel is not registered it sets it up automatically.
- /// If it had been previously registered, then the bus is simply returned.
- ///
- /// The channel.
- /// The frequency.
- /// The usable SPI channel.
- internal static ISpiChannel Retrieve(SpiChannelNumber channel, int frequency)
- {
- lock (SyncRoot)
- {
- if (Buses.ContainsKey(channel))
- return Buses[channel];
-
- var newBus = new SpiChannel(channel, frequency);
- Buses[channel] = newBus;
- return newBus;
- }
- }
- }
+ public const Int32 MinFrequency = 500000;
+
+ ///
+ /// The maximum frequency of a SPI channel.
+ ///
+ public const Int32 MaxFrequency = 32000000;
+
+ private static readonly Object SyncRoot = new Object();
+ private static readonly Dictionary Buses = new Dictionary();
+ private readonly Object _syncLock = new Object();
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The channel.
+ /// The frequency.
+ private SpiChannel(SpiChannelNumber channel, Int32 frequency) {
+ lock(SyncRoot) {
+ this.Frequency = frequency.Clamp(MinFrequency, MaxFrequency);
+ this.Channel = (Int32)channel;
+ this.FileDescriptor = Native.WiringPi.WiringPiSPISetup((Int32)channel, this.Frequency);
+
+ if(this.FileDescriptor < 0) {
+ HardwareException.Throw(nameof(SpiChannel), channel.ToString());
+ }
+ }
+ }
+
+ ///
+ public Int32 FileDescriptor {
+ get;
+ }
+
+ ///
+ public Int32 Channel {
+ get;
+ }
+
+ ///
+ public Int32 Frequency {
+ get;
+ }
+
+ ///
+ public Byte[] SendReceive(Byte[] buffer) {
+ if(buffer == null || buffer.Length == 0) {
+ return null;
+ }
+
+ lock(this._syncLock) {
+ Byte[] spiBuffer = new Byte[buffer.Length];
+ Array.Copy(buffer, spiBuffer, buffer.Length);
+
+ Int32 result = Native.WiringPi.WiringPiSPIDataRW(this.Channel, spiBuffer, spiBuffer.Length);
+ if(result < 0) {
+ HardwareException.Throw(nameof(SpiChannel), nameof(SendReceive));
+ }
+
+ return spiBuffer;
+ }
+ }
+
+ ///
+ /// Sends data and simultaneously receives the data in the return buffer.
+ ///
+ /// The buffer.
+ ///
+ /// The read bytes from the ring-style bus.
+ ///
+ public Task SendReceiveAsync(Byte[] buffer) => Task.Run(() => this.SendReceive(buffer));
+
+ ///
+ public void Write(Byte[] buffer) {
+ lock(this._syncLock) {
+ Int32 result = Native.SysCall.Write(this.FileDescriptor, buffer, buffer.Length);
+
+ if(result < 0) {
+ HardwareException.Throw(nameof(SpiChannel), nameof(Write));
+ }
+ }
+ }
+
+ ///
+ /// Writes the specified buffer the the underlying FileDescriptor.
+ /// Do not use this method if you expect data back.
+ /// This method is efficient if used in a fire-and-forget scenario
+ /// like sending data over to those long RGB LED strips.
+ ///
+ /// The buffer.
+ /// The awaitable task.
+ public Task WriteAsync(Byte[] buffer) => Task.Run(() => { this.Write(buffer); });
+
+ ///
+ /// Retrieves the spi bus. If the bus channel is not registered it sets it up automatically.
+ /// If it had been previously registered, then the bus is simply returned.
+ ///
+ /// The channel.
+ /// The frequency.
+ /// The usable SPI channel.
+ internal static ISpiChannel Retrieve(SpiChannelNumber channel, Int32 frequency) {
+ lock(SyncRoot) {
+ if(Buses.ContainsKey(channel)) {
+ return Buses[channel];
+ }
+
+ SpiChannel newBus = new SpiChannel(channel, frequency);
+ Buses[channel] = newBus;
+ return newBus;
+ }
+ }
+ }
}
diff --git a/Unosquare.WiringPi/SystemInfo.cs b/Unosquare.WiringPi/SystemInfo.cs
index 55f0938..dc4314e 100644
--- a/Unosquare.WiringPi/SystemInfo.cs
+++ b/Unosquare.WiringPi/SystemInfo.cs
@@ -1,45 +1,42 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
- using System;
-
- ///
- /// Represents the WiringPi system info.
- ///
- ///
- public class SystemInfo : ISystemInfo
- {
- private static readonly object Lock = new object();
- private static bool _revGetted;
- private static BoardRevision _boardRevision = BoardRevision.Rev2;
-
- ///
- public BoardRevision BoardRevision => GetBoardRevision();
-
- ///
- public Version LibraryVersion
- {
- get
- {
- var libParts = WiringPi.WiringPiLibrary.Split('.');
- var major = int.Parse(libParts[libParts.Length - 2]);
- var minor = int.Parse(libParts[libParts.Length - 1]);
- return new Version(major, minor);
- }
- }
-
- internal static BoardRevision GetBoardRevision()
- {
- lock (Lock)
- {
- if (_revGetted) return _boardRevision;
- var val = WiringPi.PiBoardRev();
- _boardRevision = val == 1 ? BoardRevision.Rev1 : BoardRevision.Rev2;
- _revGetted = true;
- }
-
- return _boardRevision;
- }
- }
+using System;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Represents the WiringPi system info.
+ ///
+ ///
+ public class SystemInfo : ISystemInfo {
+ private static readonly Object Lock = new Object();
+ private static Boolean _revGetted;
+ private static BoardRevision _boardRevision = BoardRevision.Rev2;
+
+ ///
+ public BoardRevision BoardRevision => GetBoardRevision();
+
+ ///
+ public Version LibraryVersion {
+ get {
+ String[] libParts = Native.WiringPi.WiringPiLibrary.Split('.');
+ Int32 major = Int32.Parse(libParts[libParts.Length - 2]);
+ Int32 minor = Int32.Parse(libParts[libParts.Length - 1]);
+ return new Version(major, minor);
+ }
+ }
+
+ internal static BoardRevision GetBoardRevision() {
+ lock(Lock) {
+ if(_revGetted) {
+ return _boardRevision;
+ }
+
+ Int32 val = Native.WiringPi.PiBoardRev();
+ _boardRevision = val == 1 ? BoardRevision.Rev1 : BoardRevision.Rev2;
+ _revGetted = true;
+ }
+
+ return _boardRevision;
+ }
+ }
}
diff --git a/Unosquare.WiringPi/Threading.cs b/Unosquare.WiringPi/Threading.cs
index ada771e..474179f 100644
--- a/Unosquare.WiringPi/Threading.cs
+++ b/Unosquare.WiringPi/Threading.cs
@@ -1,72 +1,71 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
- using RaspberryIO.Abstractions.Native;
- using Swan;
- using System;
-
+using System;
+
+using Swan;
+
+using Unosquare.RaspberryIO.Abstractions;
+using Unosquare.RaspberryIO.Abstractions.Native;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Use this class to access threading methods using interop.
+ ///
+ ///
+ public class Threading : IThreading {
///
- /// Use this class to access threading methods using interop.
+ /// This attempts to shift your program (or thread in a multi-threaded program) to a higher priority and
+ /// enables a real-time scheduling. The priority parameter should be from 0 (the default) to 99 (the maximum).
+ /// This won’t make your program go any faster, but it will give it a bigger slice of time when other programs
+ /// are running. The priority parameter works relative to others – so you can make one program priority 1 and
+ /// another priority 2 and it will have the same effect as setting one to 10 and the other to 90
+ /// (as long as no other programs are running with elevated priorities).
///
- ///
- public class Threading : IThreading
- {
- ///
- /// This attempts to shift your program (or thread in a multi-threaded program) to a higher priority and
- /// enables a real-time scheduling. The priority parameter should be from 0 (the default) to 99 (the maximum).
- /// This won’t make your program go any faster, but it will give it a bigger slice of time when other programs
- /// are running. The priority parameter works relative to others – so you can make one program priority 1 and
- /// another priority 2 and it will have the same effect as setting one to 10 and the other to 90
- /// (as long as no other programs are running with elevated priorities).
- ///
- /// The priority.
- public void SetThreadPriority(int priority)
- {
- priority = priority.Clamp(0, 99);
- var result = WiringPi.PiHiPri(priority);
- if (result < 0) HardwareException.Throw(nameof(Timing), nameof(SetThreadPriority));
- }
-
- ///
- /// These allow you to synchronize variable updates from your main program to any threads running in your program.
- /// keyNum is a number from 0 to 3 and represents a “key”. When another process tries to lock the same key,
- /// it will be stalled until the first process has unlocked the same key.
- ///
- /// The key.
- public void Lock(ThreadLockKey key) => WiringPi.PiLock((int)key);
-
- ///
- /// These allow you to synchronize variable updates from your main program to any threads running in your program.
- /// keyNum is a number from 0 to 3 and represents a “key”. When another process tries to lock the same key,
- /// it will be stalled until the first process has unlocked the same key.
- ///
- /// The key.
- public void Unlock(ThreadLockKey key) => WiringPi.PiUnlock((int)key);
-
- ///
- ///
- /// This is really nothing more than a simplified interface to the Posix threads mechanism that Linux supports.
- /// See the manual pages on Posix threads (man pthread) if you need more control over them.
- ///
- /// worker.
- public void StartThread(Action worker)
- {
- if (worker == null)
- throw new ArgumentNullException(nameof(worker));
-
- var result = WiringPi.PiThreadCreate(new ThreadWorker(worker));
-
- if (result != 0)
- HardwareException.Throw(nameof(Timing), nameof(StartThread));
- }
-
- ///
- public UIntPtr StartThreadEx(Action worker, UIntPtr userData) =>
- throw new NotSupportedException("WiringPi does only support a simple thread callback that has no parameters.");
-
- ///
- public void StopThreadEx(UIntPtr handle) =>
- throw new NotSupportedException("WiringPi does not support stopping threads.");
- }
+ /// The priority.
+ public void SetThreadPriority(Int32 priority) {
+ priority = priority.Clamp(0, 99);
+ Int32 result = Native.WiringPi.PiHiPri(priority);
+ if(result < 0) {
+ HardwareException.Throw(nameof(Timing), nameof(SetThreadPriority));
+ }
+ }
+
+ ///
+ /// These allow you to synchronize variable updates from your main program to any threads running in your program.
+ /// keyNum is a number from 0 to 3 and represents a “key”. When another process tries to lock the same key,
+ /// it will be stalled until the first process has unlocked the same key.
+ ///
+ /// The key.
+ public void Lock(ThreadLockKey key) => Native.WiringPi.PiLock((Int32)key);
+
+ ///
+ /// These allow you to synchronize variable updates from your main program to any threads running in your program.
+ /// keyNum is a number from 0 to 3 and represents a “key”. When another process tries to lock the same key,
+ /// it will be stalled until the first process has unlocked the same key.
+ ///
+ /// The key.
+ public void Unlock(ThreadLockKey key) => Native.WiringPi.PiUnlock((Int32)key);
+
+ ///
+ ///
+ /// This is really nothing more than a simplified interface to the Posix threads mechanism that Linux supports.
+ /// See the manual pages on Posix threads (man pthread) if you need more control over them.
+ ///
+ /// worker.
+ public void StartThread(Action worker) {
+ if(worker == null) {
+ throw new ArgumentNullException(nameof(worker));
+ }
+
+ Int32 result = Native.WiringPi.PiThreadCreate(new Native.ThreadWorker(worker));
+
+ if(result != 0) {
+ HardwareException.Throw(nameof(Timing), nameof(StartThread));
+ }
+ }
+
+ ///
+ public UIntPtr StartThreadEx(Action worker, UIntPtr userData) => throw new NotSupportedException("WiringPi does only support a simple thread callback that has no parameters.");
+
+ ///
+ public void StopThreadEx(UIntPtr handle) => throw new NotSupportedException("WiringPi does not support stopping threads.");
+ }
}
diff --git a/Unosquare.WiringPi/Timing.cs b/Unosquare.WiringPi/Timing.cs
index de36444..8756ead 100644
--- a/Unosquare.WiringPi/Timing.cs
+++ b/Unosquare.WiringPi/Timing.cs
@@ -1,36 +1,35 @@
-namespace Unosquare.WiringPi
-{
- using Native;
- using RaspberryIO.Abstractions;
-
+using System;
+
+using Unosquare.RaspberryIO.Abstractions;
+
+namespace Unosquare.WiringPi {
+ ///
+ /// Provides access to timing and threading properties and methods.
+ ///
+ public class Timing : ITiming {
+ ///
///
- /// Provides access to timing and threading properties and methods.
+ /// This returns a number representing the number of milliseconds since your program
+ /// initialized the GPIO controller.
+ /// It returns an unsigned 32-bit number which wraps after 49 days.
///
- public class Timing : ITiming
- {
- ///
- ///
- /// This returns a number representing the number of milliseconds since your program
- /// initialized the GPIO controller.
- /// It returns an unsigned 32-bit number which wraps after 49 days.
- ///
- public uint Milliseconds => WiringPi.Millis();
-
- ///
- ///
- /// This returns a number representing the number of microseconds since your
- /// program initialized the GPIO controller
- /// It returns an unsigned 32-bit number which wraps after approximately 71 minutes.
- ///
- public uint Microseconds => WiringPi.Micros();
-
- ///
- public static void Sleep(uint millis) => WiringPi.Delay(millis);
-
- ///
- public void SleepMilliseconds(uint millis) => Sleep(millis);
-
- ///
- public void SleepMicroseconds(uint micros) => WiringPi.DelayMicroseconds(micros);
- }
+ public UInt32 Milliseconds => Native.WiringPi.Millis();
+
+ ///
+ ///
+ /// This returns a number representing the number of microseconds since your
+ /// program initialized the GPIO controller
+ /// It returns an unsigned 32-bit number which wraps after approximately 71 minutes.
+ ///
+ public UInt32 Microseconds => Native.WiringPi.Micros();
+
+ ///
+ public static void Sleep(UInt32 millis) => Native.WiringPi.Delay(millis);
+
+ ///
+ public void SleepMilliseconds(UInt32 millis) => Sleep(millis);
+
+ ///
+ public void SleepMicroseconds(UInt32 micros) => Native.WiringPi.DelayMicroseconds(micros);
+ }
}