nanoFramework IoT.Device Library

The System.Numerics library provides mathematical primitives for .NET nanoFramework. It is used for high-performance numerical computations, such as vector and quaternion operations, which are essential for IoT applications involving sensor fusion, robotics, or spatial tracking.

Important Limitations: As of the current implementation, the following types are not supported:

• Matrix4x4
• Plane

The nanoFramework Code Converter is a tool designed to facilitate the migration of code from .NET IoT, .NET Core, or .NET 5.0 to .NET nanoFramework.

Key capabilities include:

• Creating a new solution structure.
• Transforming .csproj files into .nfproj files.
• Automatically identifying and adding necessary NuGet packages (including mscorlib).
• Adding references to shared projects.
• Transforming generic collections (e.g., converting List<Something> to a non-generic ListSomething) to work around the current lack of generics support in nanoFramework.

The nanoFramework binding for the Raspberry Pi Build HAT allows you to control LEGO® Technic™ motors and sensors via the 40-pin GPIO header of a Raspberry Pi.

Key details for developers:

• Firmware Management: The Build HAT does not come with pre-loaded firmware. This binding automatically embeds and uploads the required firmware upon connection. Note that the first initialization may take several seconds.
• Compatibility: While the implementation attempts compatibility with the BrickPi3 philosophy, the underlying low-level implementation and sensor handling are distinct. You should expect a model based on a Brick containing various Motors and Sensors.

The nanoFramework IoT.Device repository provides bindings for sensors, small displays, and other peripheral devices that can be connected to nanoFramework-compatible microcontrollers.

Most of these bindings are migrated from the .NET IoT repository. Note that migration efforts focus on devices compatible with the .NET nanoFramework ecosystem, and some migrated devices may be untested and could exhibit issues.

The FT232H chipset implementation provides SPI, GPIO, and I2C drivers for Windows (32/64-bit), MacOS, and Linux. It utilizes the FTDI D2xx drivers and the Multi-Protocol Synchronous Serial Engine (MPSSE) to communicate with synchronous protocols like SPI and JTAG efficiently.

Requirements

• The D2xx drivers must be installed on your machine (Windows, MacOS, or Linux).
• The hardware (e.g., an Adafruit FT232H board) must be connected via USB.

The repository is organized into two main types of device implementations:

• /devices/: Contains cleaned-up, production-ready device bindings that should work out of the box.
• /src/devices_generated/: Contains devices automatically ported from the .NET Core IoT Libraries. These are experimental and may not compile or work immediately, but serve as a starting point for missing device support.

Additional resources in /src include the nanoFramework.IoT.Device.CodeConverter tool and helper projects like StopWatch, DelayHelper, and BinaryPrimitives which can be referenced when creating or updating devices.

This integration implements the Home Assistant MQTT Discovery protocol, allowing nanoFramework devices to automatically register entities in Home Assistant and synchronize states over MQTT.

Key features include:

• MQTT Discovery: Automatic entity registration upon connection.
• Auto-generated topics: State and command topics are derived from device and entity names.
• Availability tracking: Uses Last-Will-Testament (LWT) to mark devices as offline if they disconnect ungracefully.
• HA restart detection: Re-publishes discovery and state when Home Assistant becomes available again.

The nanoframework.iot.device repository provides a collection of NuGet packages for various hardware components, including sensors, motor drivers, displays, and communication modules. Each device has a dedicated NuGet package that can be installed into your .NET nanoFramework project.

Common categories of supported devices include:

• Sensors: Accelerometers (ADXL343, ADXL345), Temperature/Humidity (AHTxx, DHTxx, AM2320), Gas (CCS811, AGS01DB), Magnetometers (AK8963, BMM150), and Light sensors (BH1745, BH1750FVI).
• Actuators/Motors: Stepper motors (ULN2003, A4988, DRV8825), DC Motor controllers, and Buzzers.
• Displays: Character LCDs and ePaper drivers.
• Networking/System: DHCP Servers, DNS Servers, and Realtime Clocks (DS1302).
• Audio: Audio ADCs (ES7210, ES7243E) and DACs (ES8156).

The nanoFramework.iot.device repository provides a wide range of NuGet packages for interfacing with various hardware components including sensors, motors, displays, and communication modules. Each device has a dedicated NuGet package that can be installed into your .NET nanoFramework project.

Common categories include:

• Sensors: Accelerometers (ADXL345, ADXL343), Temperature/Humidity (SHT3x, DHTxx, BME280), Gas (CCS811, MH-Z19B), and Light (BH1750, TSL256x).
• Actuators/Motors: Stepper motors (A4988, ULN2003), DC Motors, and Servos.
• Displays: OLED (SSD13xx), LCD (Character LCD, SparkFun LCD), and ePaper.
• Communication: Modbus, RFID/NFC (PN532, MFRC522), and Radio Transceivers.
• Utilities: Real-time Clocks (RTC), GPIO Expanders (MCP23xxx), and Power Management (AXP192).

The repository is organized into specific directories depending on the readiness and origin of the device drivers:

• /devices/: Contains cleaned, production-ready device bindings that are ready for direct use.
• /src/devices_generated/: Contains devices automatically ported from .NET Core IoT Libraries. These may not compile or work immediately and should be treated as starting points for manual porting.
• /src/nanoFramework.IoT.Device.CodeConverter: Contains the tool used to generate device bindings from .NET Core code.
• /src/: Contains supporting nanoFramework projects (e.g., StopWatch, DelayHelper, BinaryPrimitives, or System.Device.Model extensions) that should be referenced when creating or updating device bindings.