Name		Name	Last commit message	Last commit date
parent directory ..
AD5328		AD5328
Ads1115		Ads1115
Adxl345		Adxl345
Adxl357		Adxl357
Ags01db		Ags01db
Ahtxx		Ahtxx
Ak8963		Ak8963
Amg88xx		Amg88xx
Apa102		Apa102
Arduino		Arduino
Bh1745		Bh1745
Bh1750fvi		Bh1750fvi
Bmp180		Bmp180
Bmxx80		Bmxx80
Bno055		Bno055
Board		Board
BoardLed		BoardLed
BrickPi3		BrickPi3
Buzzer		Buzzer
Card		Card
Ccs811		Ccs811
CharacterLcd		CharacterLcd
Charlieplex		Charlieplex
Common		Common
CpuTemperature		CpuTemperature
DCMotor		DCMotor
Dhtxx		Dhtxx
Display		Display
ExplorerHat		ExplorerHat
Ft232H		Ft232H
Ft4222		Ft4222
FtCommon		FtCommon
GoPiGo3		GoPiGo3
Gpio		Gpio
GrovePi		GrovePi
HardwareMonitor		HardwareMonitor
Hcsr04		Hcsr04
Hcsr501		Hcsr501
Hmc5883l		Hmc5883l
Hts221		Hts221
Ina219		Ina219
Interop		Interop
KeyMatrix		KeyMatrix
LidarLiteV3		LidarLiteV3
LiquidLevel		LiquidLevel
Lm75		Lm75
Lps25h		Lps25h
Lsm9Ds1		Lsm9Ds1
Max31856		Max31856
Max31865		Max31865
Max44009		Max44009
Max7219		Max7219
Mbi5027		Mbi5027
Mcp23xxx		Mcp23xxx
Mcp25xxx		Mcp25xxx
Mcp3428		Mcp3428
Mcp3xxx		Mcp3xxx
Mcp960x		Mcp960x
Mcp9808		Mcp9808
Media		Media
Mfrc522		Mfrc522
Mhz19b		Mhz19b
Mlx90614		Mlx90614
MotorHat		MotorHat
Mpr121		Mpr121
Mpu9250		Mpu9250
Nrf24l01		Nrf24l01
OneWire		OneWire
Pca95x4		Pca95x4
Pca9685		Pca9685
Pcd8544		Pcd8544
Pcx857x		Pcx857x
PiJuice		PiJuice
Pn5180		Pn5180
Pn532		Pn532
RGBLedMatrix		RGBLedMatrix
RadioReceiver		RadioReceiver
RadioTransmitter		RadioTransmitter
RotaryEncoder		RotaryEncoder
Rtc		Rtc
Seesaw		Seesaw
SenseHat		SenseHat
SensorHub		SensorHub
ServoMotor		ServoMotor
ShiftRegister		ShiftRegister
Sht3x		Sht3x
Shtc3		Shtc3
Si7021		Si7021
Sn74hc595		Sn74hc595
SocketCan		SocketCan
SoftPwm		SoftPwm
SoftwareSpi		SoftwareSpi
Ssd1351		Ssd1351
Ssd13xx		Ssd13xx
StUsb4500		StUsb4500
System.Device.Model		System.Device.Model
Tcs3472x		Tcs3472x
Tlc1543		Tlc1543
Tm1637		Tm1637
Tsl256x		Tsl256x

README.md

Device Bindings

This directory is intended for device bindings, sensors, displays, human interface devices and anything else that requires software to control. We want to establish a rich set of quality .NET bindings to make it straightforward to use .NET to connect devices together to produce weird and wonderful IoT applications.

Our vision: the majority of .NET bindings are written completely in .NET languages to enable portability, use of a single tool chain and complete debugability from application to binding to driver.

Bindings by category

Alphabetical device index can be found here

Analog/Digital converters

Digital/Analog converters

AD5328 - Digital to Analog Convertor

Accelerometers

Gas sensors

Liquid sensors

Light sensor

Barometers

Altimeters

Thermometers

Infrared sensors

Gyroscopes

Compasses

Lego related devices

BrickPi3

Motor controllers/drivers

Inertial Measurement Units

Magnetometers

Hygrometers

Clocks

Realtime Clock

Sonars

HC-SR04 - Ultrasonic Ranging Module

Distance sensors

Passive InfraRed (motion) sensors

HC-SR501 - PIR Motion Sensor

Motion sensors

HC-SR501 - PIR Motion Sensor

Displays

GPIO Expanders

CAN BUS libraries/modules

Proximity sensors

MPR121 - Proximity Capacitive Touch Sensor Controller

Touch sensors

Wireless communication modules

Joysticks

Sense HAT

Color sensors

TCS3472x Sensors

LED drivers

RFID/NFC modules

Media libraries

USB devices

GPIO or bit operating devices

Multi-device or robot kit

Protocols providers/libraries

Power monitors and related devices

Binding Distribution

These bindings are distributed via the Iot.Device.Bindings NuGet package. Daily builds with the latest bindings are available on MyGet. You can also consume the bindings as source.

Contributing a binding

Anyone can contribute a binding. Please do! Bindings should follow the model that is used for the Mcp23xxx or Mcp3xxx implementations. There is a Device Binding Template that can help you get started, as well.

Bindings must:

include a .NET Core project file for the main library.
include a descriptive README, with a fritzing diagram.
- Best if you include the coverage of the binding. If you did not implement all features, mention what has been implemented and what is not. It is ok not to implement every features but it's important to know what is missing
- Refer to multiple manufacturer and add links where the binding can be found. Sometimes, they have different names depending on where you can find them while it's the same chipset used or compatible ones
include a buildable sample (layout will be described below).
- Best if you include a sample that covers usage of all available functions and properties
- Best if you create mutliple paths to show what the sensor can do
use the System.Device API.
(Optional) Include a unit test project that DOES NOT require hardware for testing. We will be running these tests as part of our CI and we won't have sensors plugged in to the microcontrollers, which is why test projects should only contain unit tests for small components in your binding.

Here is an example of a layout of a new Binding Foo from the top level of the repo:

iot/
  src/
    devices/
      Foo/
        Foo.csproj
        Foo.cs
        README.md
        samples/
          Foo.Sample.csproj
          Foo.Sample.cs
        tests/   <--  Tests are optional, but if present they should be layed out like this.
          Foo.Tests.csproj
          Foo.Tests.cs

When creating a new binding, please follow the recommendations from the C# Coding Syle and more generally the .NET Coding Guidelinhes. On top, we recommend to use very descriptive namings, self explanatory names. Please make sure you don't use abbreviation. Describe any unit a sensor may use as well as the usual range of values. Check as well the devices convention. You will find below couple of examples of do and don't.

Using units

Do	Don't
Always use UnitsNet when possible:	Don't implement your own:
`public void SetEnvironmentData(Temperature temperature, Ratio humidity)`	`public void SetEnvironmentData(float temperature, float humidity)`
Temperature is a classic one, you have lots of available units available, check here if anything exists before starting	In this case, there are existing units, use the existing one

Do	Don't
Decribe your unit if it does not exist in UnitsNet	Leave an unkonwn measurement element
`public bool TryGetMyUnit(out double myUnitInUnitDescription)`	`public bool TryGetMyUnit(out double myUnit)`
In this case, you need to speciy in the variable name the unit used. Be as precise as possible	Never leave any unit without description in the naming if it's not an support UnitsNet unit.

Do	Don't
Always add range of the units in the XML description	Never leave a unit without a full range description
`/// <param name="equivalentCO2">The equivalent CO2 (eCO2) output range for CCS811 is from 400ppm up to 29206ppm.</param>`	`/// <param name="equivalentCO2">The equivalent CO2 (eCO2)</param>`
Even when using the UnitsNet, make sure you give the usual range of a sensor value.	This makes it difficult to understand which range the sensor is using.

Naming of functions

Do
When reading a sensor can fail prefix a method name with `Try` for example:
`public bool TryGetTemperature(out Temperature temperature)`
This makes it easy to understand that if you read and the returned value is `false` the reading is not correct. And this means as well this function should not raise an exception when trying to read the sensor data if the data is not valid for example. You still can get exceptions like IO Errors or user errors. For example if the function takes parameters with a specific range, and the user is out of this range, then an Argument Exception can be raised.

Do
Use action verbs for any function that makes an action.
`public void SetEnvironmentData(Temperature temperature, Ratio humidity)`
In this example, the function Set the environement values of temperature and humidity. It makes it very easy to understand, on top of the XML comment what the function is doing.

Do
Use properties for a single element Set and/or Get function
`public OperationMode OperationMode`
This function then can be implemented with a get and set:

public OperationMode OperationMode
{
    get
    {
        var mode = ReadRegister(Register.MEAS_MODE);
        mode = (byte)((mode >> 4) & 0b0000_0111);
        return (OperationMode)mode;
    }

    set
    {
        var mode = ReadRegister(Register.MEAS_MODE);
        // Clear previous mode
        mode = (byte)(mode & 0b1000_1111);
        mode = (byte)(mode | (((byte)(value)) << 4));
        WriteRegister(Register.MEAS_MODE, mode);
    }
}

Do	Don't
Use full name like `EquivalentTotalVolatileOrganicCompound`	Don't use the abbreviation `eTVOC`
This makes it easy for non specialist to use a binding.	If you are not a specialist or depending of the context, the abbreviation is complicated to understand.
You can use abbreviation for the very common ones like Html, Xml, Jpeg or any other very well known. But those abreviation has to be very common one and used like this everywhere

Commenting the code

Do
Use the `<remarks>` from the XML comments to add any important element regarding a function.

/// <remarks>A previously stored value may be written back to this two byte
/// register and the Algorithms will use the new value in its
/// calculations(until it adjusts it as part of its internal Automatic
/// Baseline Correction). Please refer to documentation to understand when to restore a
/// previous baseline: https://www.sciosense.com/wp-content/uploads/2020/01/Application-Note-Baseline-Save-and-Restore-on-CCS811.pdf</remarks>

Do

Do
Always reference specific elements with a pointer documentation/reference to a specific part of the documentation. This does including specific timing wait, initialization phase and anything that would trigger a question like `why this wait?` or `Why this function has to be called 2 times in a row`. If the documentation is the same for all the sensor implementation, refer the documentation once at the beginning and then mention the page.
For example:

Always reference specific elements with a pointer documentation/reference to a specific part of the documentation. This does including specific timing wait, initialization phase and anything that would trigger a question like why this wait? or Why this function has to be called 2 times in a row. If the documentation is the same for all the sensor implementation, refer the documentation once at the beginning and then mention the page.

For example:

_controller.Write(_pinWake, PinValue.Low);
// Doc says wait 50 micro seconds, page 58 https://urltothedoc
DelayHelper.DelayMicroseconds(50, true);

GpioController

Do
In a constructor if you are using a `GpioController` make sure you are using as well a boolean `_shouldDispose`. Some platforms or some specific dongles like FT4222 does allow the creation of one controller so if used with multiple bindings, it can't be disposed just like that. In the `Dispose` function, make sure you close the possible open pins if `_shouldDispose` is false.
Example of an correct implementation:

private GpioController _controller;
private bool _shouldDispose;
private int _pinToUse;

public MyBinding(int pinToUse, GpioController controller = null, PinNumberingScheme pinNumberingScheme = PinNumberingScheme.Logical, bool shouldDispose = true)
{
  _shouldDispose = gpioController is null || shouldDispose;
  _controller = gpioController ?? new GpioController(pinNumberingScheme);  
  _pinToUse = pinToUse;
  _controller.OpenPin(_pinToUse);
  // Initialize the rest of initialization
}

public Dispose()
{
  if (_shouldDispose)
  {
    _controller?.Dispose();
  }
  else
  {
    _controller?.ClosePin(_thePinToUse);
  }
}

Licences

We are currently not accepting samples that rely on native libraries for hardware interaction. This is for two reasons: we want feedback on the System.Device API and we want to encourage the use of 100% portable .NET solutions. If a native library is used to enable precise timing, please file an issue so that we can discuss your proposed contribution further.

We will only accept samples that use the MIT or compatible licenses (BSD, Apache 2, ...). We will not accept samples that use GPL code or were based on an existing GPL implementation. It is critical that these samples can be used for commercial applications without any concern for licensing.

Files

devices

Directory actions

More options