Skip to main content

08: .NET nanoFramework GPIO, I2C, SPI and other IO support

· 11 min read
Laurent Ellerbach
José Simões

Welcome to Day 8 of #JulyOT!

Page banner

GPIO, I2C, SPI, PWM, ADC, DAC, Serial and more!

.NET nanoFramework has support for GPIO, I2C, SPI, PWM, ADC, DAC, Serial, 1-Wire. Also the API are aligned with .NET IoT making it easy for code reuse between development on a Raspberry Pi with .NET 6.0 and an MCU running .NET nanoFramework.

A comparison on how to reuse code and the differences between .NET IoT and .NET nanoFramework is available here.

There are dedicated classes with detailed documentation and samples for each of them:

  • General Purpose Input and Output (GPIO): System.Device.Gpio and associated documentation for the class library

    And a code snipet to blink a led:

    // Creates a GPIO controller
    GpioController controller = new();
    // Open the pin
    GpioPin led = controller.OpenPin(12, PinMode.Output);
    // Change the value of the pin. Equivalent code as the next line: controller.Write(12, PinValue.Low)
    while (true)
    // Toggle the value of the pin

    Blink your first led! GPIO sample pack including event management.

  • Serial Peripheral Interface (SPI): System.Device.Spiand associated document for the class library

    To create a SpiDevice, you need to follow this pattern:

    SpiDevice spiDevice;
    SpiConnectionSettings connectionSettings;
    // Note: the ChipSelect pin should be adjusted to your device, here 12
    // You can adjust as well the bus, here 1 for SPI1
    connectionSettings = new SpiConnectionSettings(1, 12);
    spiDevice = SpiDevice.Create(connectionSettings);

    You can write a SpanByte like this:

    SpanByte writeBuffer = new byte[2] { 42, 84 };

    You can write a ushort array like this:

    ushort[] writeBuffer = new ushort[2] { 4200, 8432 };

    You can write single bytes:


    Read operations are similar:

    SpanByte readBuffer = new byte[2];
    // This will read 2 bytes
    ushort[] readUshort = new ushort[4];
    // This will read 4 ushort
    // read 1 byte
    byte readMe = spiDevice.ReadByte();

    For full transfer, you need to have 2 arrays of the same size and perform a full duplex transfer:

    SpanByte writeBuffer = new byte[4] { 0xAA, 0xBB, 0xCC, 0x42 };
    SpanByte readBuffer = new byte[4];
    spiDevice.TransferFullDuplex(writeBuffer, readBuffer);
    // Same for ushirt arrays:
    ushort[] writeBuffer = new ushort[4] { 0xAABC, 0x00BB, 0xCC00, 0x4242 };
    ushort[] readBuffer = new ushort[4];
    spiDevice.TransferFullDuplex(writeBuffer, readBuffer);

    More System.Device.Spi samples.

  • Inter-Integrated Circuit (I2C): System.Device.I2c and associated document for the class library

    Here is a short example on how to use I2C:

    // In this case we are opening the bus 1 and the device address 0x42
    I2cDevice i2c = new(new I2cConnectionSettings(1, 0x42));
    // We write a byte, in this case 0x07, we can write a SpanByte as well
    var res = i2c.WriteByte(0x07);
    // A successfull write will be: 0x10 Write: 1, transferred: 1
    // A non successful one: 0x0F Write: 4, transferred: 0
    Debug.Write($"0x{i:X2} Write: {res.Status}, transferred: {res.BytesTransferred}");
    // We're now trying to read 2 bytes
    SpanByte span = new byte[2];
    res = i2c.Read(span);
    // A successfull write will be: Read: 1, transferred: 1
    // A non successfull one: Read: 2, transferred: 0
    Debug.WriteLine($", Read: {res.Status}, transferred: {res.BytesTransferred}");

    I2C sample sample pack containing as well I2C GPS sample and an I2C Scanner sample.

  • Digital-to-analog converter (DAC): System.Device.Dac and associated document for the class library

    A simple example for DAC is to create a specific sinus wave for example:

    // Gets the controller
    DacController dac = DacController.GetDefault();
    // Open channel 0
    DacChannel dacChannel = dac.OpenChannel(0);
    // Gete DAC resolution
    dacResolution = dac.ResolutionInBits;

    int upperValue, midRange;
    double radian = 0;
    // Gets upper value from DAC resolution
    upperValue = (int)Math.Pow(2.0, dacResolution);

    // compute a reasonable increment value from the resolution
    float increment = maxRads / (dacResolution * 10);
    midRange = upperValue / 2;

    // because the DAC can't output negative values
    // we have to offset the sine wave to half the DAC output range
    uint value = (uint)((Math.Sin(radian) * (midRange - 1)) + midRange);
    //Output the current value to console when in debug.
    Debug.WriteLine($"DAC SineWave output current value: {value}");
    // output to DAC
    // increment angle
    radian += increment;
    if (radian >= maxRads)
    // tweak the value so it doesn't overflow the DAC
    radian = 0;

    // Wait 5 milliseconds before the next point

    Digital Analog Converter samples.

  • Analog-to-digital converter (ADC): System.Device.Adc and associated document for the class library

    Each target device has an ADC Controller. To read a channel, first, instantiate the ADC controller and open the channel you want to read from. To read the raw value from an ADC channel, it's a simple matter of calling the Read() method on an open channel.

    AdcController adc1 = new AdcController();
    AdcChannel channel0 = adc1.OpenChannel(0);
    int myAdcRawvalue = channel0.ReadValue();

    To find details about the ADC controller, query the ADC controller properties, like this.

    // get maximum raw value from the ADC controller
    int max1 = adc1.MaxValue;
    // get minimum raw value from the ADC controller
    int min1 = adc1.MinValue;
    // find how many channels are available
    int channelCount = adc1.ChannelCount;
    // resolution provided by the ADC controller
    int adcResolution = adc1.ResolutionInBits;

    Analogic/Digital converter sample.

  • Pulse-width Modulation (PWM): System.Device.Pwm and associated document for the class library

    You can create a PWM channel from a pin number. For an ESP32 device, allocate the pin, for an STM32 device ensure the selected pin is PWM enabled.

    // Case of ESP32, you need to set the pin function, in this example PWM3 for pin 18:
    Configuration.SetPinFunction(18, DeviceFunction.PWM3);
    PwmChannel pwmPin = PwmChannel.CreateFromPin(18, 40000);
    // You can check then if it has created a valid one:
    if (pwmPin != null)
    // You do have a valid one

    You can adjust the duty cycle by using the property:

    pwmPin.DutyCycle = 0.42;

    The duty cycle goes from 0.0 to 1.0.

    It is recommended to set the frequency when creating the PWM Channel. You can technically change it at any time but keep in mind some platforms may not behave properly when adjusting this element.

    Alternatively, if you know the chip/timer Id and the channel then follow this example:

    PwmChannel pwmPin = new(1, 2, 40000, 0.5);

    More on System.Device.Pwm sample.

  • Serial Port: System.IO.Portsand associated documentation for the class library

    Serial ports are often used to communicate with sensors. The SerialPort must be first opened before it can be used. The serial port can also be closed, when the serial port is disposed, the SerialPort will perform the close operation regardless of any ongoing receive or transmit operations.

    // You can specify baud rate, parity, bit stops and number of bits as well:
    var port = new SerialPort("COM2");
    // Do a lot of things here, write, read

    There are functions to read and write, some are byte related, others string related. Note that string functions will use UTF8 Encoding charset.

    Example of sending and reading byte arrays:

    byte[] toSend = new byte[] { 0x42, 0xAA, 0x11, 0x00 };
    byte[] toReceive = new byte[50];
    // this will send the 4 bytes:
    port.Write(toSend, 0, toSend.Length);
    // This will only send the bytes AA and 11:
    port.Write(toSend, 1, 2);
    // This will check then number of available bytes to read
    var numBytesToRead = port.BytesToRead;
    // This will read 50 characters:
    port.Read(toReceive, 0, toReceive.Length);
    // this will read 10 characters and place them at the offset position 3:
    port.Read(toReceive, 3, 10);
    // Note: in case of time out while reading or writing, you will receive a TimeoutException
    // And you can as well read a single byte:
    byte oneByte = port.ReadByte();

    Sending and receiving string example:

    string toSend = "I ❤ nanoFramework";
    // this will send the string encoded finishing by a new line, by default `\n`
    // You can change the new line to be anything:
    port.NewLine = "❤❤";
    // Now it will send 2 hearts as the line ending `WriteLine` and will use 2 hearts as the terminator for `ReadLine`.
    // You can change it back to the `\n` default at anytime:
    port.NewLine = SerialPort.DefaultNewLine; // default is "\n"
    // This will read the existing buffer:
    string existingString = port.ReadExisting();
    // Note that if it can't properly convert the bytes to a string, you'll get an exception
    // This will read a full line, it has to be terminated by the NewLine string.
    // If nothing is found ending by the NewLine in the ReadTimeout time frame, a TimeoutException will be raised.
    string aFullLine = port.ReadLine();

    SerialPort supports events when characters are received.

        // Subscribe to the event
    port.DataReceived += DataReceivedNormalEvent;

    // When you're done, you can as well unsubscribe
    port.DataReceived -= DataReceivedNormalEvent;

    private void DataReceivedNormalEvent(object sender, SerialDataReceivedEventArgs e)
    var ser = (SerialPort)sender;
    // Now you can check how many characters are available, read a line for example
    var numBytesToRead = port.BytesToRead;
    string aFullLine = ser.ReadLine();

    There are more supported. Check it in the System.IO.Ports serial Communication sample.

  • One Wire or 1-Wire: nanoFramework.Device.OneWire and associated document for the class library

    To connect to a 1-Wire bus, first, instantiate an OneWireHost object, then perform operations with the connected devices.

    OneWireHost _OneWireHost = new OneWireHost();

    To find the first device connected to the 1-Wire bus, and perform a reset on the bus before performing the search, call the `FindFirstDevice` method:

    _OneWireHost.FindFirstDevice(true, false);

    To write a byte with the value 0x44 to the connected device:


    To get a list with the serial number of all the 1-Wire devices connected to the bus:

    var deviceList = _OneWireHost.FindAllDevices();

    foreach(byte[] device in deviceList)
    string serial = "";

    foreach (byte b in device)
    serial += b.ToString("X2");


    Check out the [1-Wire sample](

    Note: devices have different ways to name pins and set them up. It is important to check the default configuration, especially for any STM32 devices. ESP32 devices can be set dynamically. A NuGet package is available for this nanoFramework.Hardware.Esp32. In that case, you would have to set the pins if they don't match your defaults pins.

    IoT Repository and advanced bindings

    The alignment between .NET IoT and .NET nanoFramework allows code reuse between the different platforms. While it's not technically possible to have the same NuGet for both platforms, reusing API and code is possible. A lot of work and effort has been put in place to facilitate the creation of individual NuGet packages for almost all of the .NET IoT bindings! The IoT Device repository contains all the tools and the code for all of the available bindings.

    The .NET nanoFramework does not yet support Generics or Linq, and in places, compromises have been made so the framework fits on constrained devices. This page explains most of them.

    Tools to help in the migration have been built to automate some of the migration and initial work started back in May 2021. Now more than 98 bindings are available, some specific for MCU and optimized for a specific platform like ESP32. .NET IoT also benefited from this work as some of those new bindings have been migrated back to .NET IoT.

    Here is a view of the devices!

    device list

    Each binding has a sample. All is well organized and you'll find those in the /devices/BindingName/samples directory. And as an example, here is how you can use a BMP280:

    // bus id on the MCU
    const int busId = 1;

    I2cConnectionSettings i2cSettings = new(busId, Bmp280.DefaultI2cAddress);
    I2cDevice i2cDevice = I2cDevice.Create(i2cSettings);
    using var i2CBmp280 = new Bmp280(i2cDevice);

    // set higher sampling
    i2CBmp280.TemperatureSampling = Sampling.LowPower;
    i2CBmp280.PressureSampling = Sampling.UltraHighResolution;

    // Perform a synchronous measurement
    var readResult = i2CBmp280.Read();

    // Print out the measured data
    Debug.WriteLine($"Temperature: {readResult.Temperature?.DegreesCelsius:N1}\u00B0C");
    Debug.WriteLine($"Pressure: {readResult.Pressure?.Hectopascals:N2}hPa");

    Note the usage of UnitsNet. UnitsNet is used to facilitate unit conversions. We've implemented the most popular unit conversions and provided them as NuGet packages. This simplifies development, for example, you don't need to worry about providing a temperature value in Celsius or Fahrenheit. It's just a temperature, the developer can choose the unit to display. The rest of the magic is done for you.