Lib.rs

portable-atomic

Portable atomic types including support for 128-bit atomics, atomic float, etc

embedded-hal

A Hardware Abstraction Layer (HAL) for embedded systems

zerocopy

makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.

elf

A pure-rust library for parsing ELF files

rhai

Embedded scripting for Rust

embedded-hal-mock

A collection of mocked devices that implement the embedded-hal traits

fixed

Fixed-point numbers

smoltcp

A TCP/IP stack designed for bare-metal, real-time systems without a heap

compiler_builtins

Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!

socketcan

Linux SocketCAN library. Send and receive CAN frames via CANbus on Linux.

critical-section

Cross-platform critical section

bitfield

macros to generate bitfield-like struct

usb-device

USB stack for embedded devices

oorandom

A tiny, robust PRNG implementation

riscv

Low level access to RISC-V processors

redox_syscall

access raw Redox system calls

defmt

A highly efficient logging framework that targets resource-constrained devices, like microcontrollers

espflash

A command-line tool for flashing Espressif devices

gdbstub

GDB Remote Serial Protocol in Rust

embedded-graphics

Embedded graphics library for small hardware displays

embassy-sync

no-std, no-alloc synchronization primitives with async support

aligned

A newtype with alignment of at least A bytes

microfft

Embedded-friendly Fast Fourier Transforms

minicov

Code coverage and profile-guided optimization support for no_std and embedded programs

pc-keyboard

PS/2 keyboard interface library

uefi

makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality

micromath

Embedded-friendly math library featuring fast floating point approximations (with small code size) for common arithmetic operations, trigonometry, 2D/3D vector types, statistical analysis…

arbitrary-int

Modern and lightweight implementation of u2, u3, u4, ..., u127

pio

Support for the Raspberry Silicon RP2040's PIO State Machines

embedded-graphics-simulator

Embedded graphics simulator

stm32-hal2

Hardware abstraction layer for the STM32 MCUs

semihosting

AArch64, Arm, RISC-V, MIPS32, MIPS64, and Xtensa

optimization_engine

A pure Rust framework for embedded nonconvex optimization. Ideal for robotics!

rp2040-hal

Embedded-HAL impl for the rp2040 microcontroller

aarch64-cpu

Low level access to processors using the AArch64 execution state

flip-link

Flips the memory layout of embedded programs to protect against stack overflows

sntpc

making SNTP requests

probe-rs

A collection of on chip debugging tools to communicate with microchips

foreign-types

A framework for Rust wrappers over C APIs

esp-backtrace

Bare-metal backtrace support for Espressif devices

tock-registers

Memory-Mapped I/O and register interface developed for Tock

managed

An interface for logically owning objects, whether or not heap allocation is available

linked_list_allocator

allocator usable for no_std systems. It builds a linked list from the freed blocks and thus needs no additional data structures.

ux

Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…

stm32f4xx-hal

Peripheral access API for STM32F4 series microcontrollers

psp

building full PSP modules, including both PRX plugins and regular homebrew apps

northstar

container runtime for Linux targetting embedded systems

embassy-executor

async/await executor designed for embedded usage

monitor_cli

Command line tool to sync monitor resources and execute file defined procedures

stm32-fmc

Hardware Abstraction Layer for STM32 Memory Controllers (FMC/FSMC)

rtt-target

Target side implementation of the RTT (Real-Time Transfer) I/O protocol

sequential-storage

storing data in flash with minimal erase cycles

imxrt-iomuxc

Pad configuration interface for NXP i.MX RT processors. Part of the imxrt-rs project

rtic

Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems

fugit

Time library for embedded targets with ease-of-use and performance first

mbedtls

Idiomatic Rust wrapper for MbedTLS, allowing you to use MbedTLS with only safe code while being able to use such great Rust features like error handling and closures. Building on MbedTLS's focus on embedded use…

eeprom24x

Platform-agnostic Rust driver for the 24x series serial EEPROMs

spidev

access to the Linux spidev interface. This interface allows for configuration of the spidev device, half-duplex SPI access, and full-duplex SPI access.

nickel-lang-cli

The Nickel interpreter CLI

avr-device

Register access crate for AVR microcontrollers

embedded-storage

A Storage Abstraction Layer for Embedded Systems

embedded-text

TextBox for embedded-graphics

atat

AT Parser for serial based device crates

pinned-init

facilitate safe pinned initialization

risc0-zkvm-platform

RISC Zero zero-knowledge VM

st-map

Runtime for a stack-alocated map

stm32-eth

Embedded Rust Ethernet driver for the STM32 MCU series

psm

Portable Stack Manipulation: stack manipulation and introspection routines

ext4-view

No-std compatible Rust library for reading ext2/ext4 filesystems

libc-print

println! and eprintln! macros on libc without stdlib

stak

Stak Scheme interpreter

industrial-io

Linux Industrial I/O (IIO) Support

espup

installing and maintaining Espressif Rust ecosystem

imxrt-ral

Register access layer for all NXP i.MX RT microcontrollers

ftdi-embedded-hal

embedded-hal implementation for FTDI USB devices

rtthost

RTT (Real-Time Transfer) client

static-alloc

A bump allocator on static memory for the alloc-traits crate

smlang

A no-std state machine language DSL

updatehub-package-schema

UpdateHub Packages metadata schemas

buddy_system_allocator

A bare metal allocator that uses buddy system

drmemd

Main process of the DrMem control system

twincatads-rs

Rust wrapper for TwinCAT ADS library provided with Beckhoff TwinCAT

pinenote_dbus_service

A DBus service for the Pine64 Pinenote

embedded-nano-mesh

Lightweight mesh communication protocol for embedded devices

disarm64

decoding ARM64 instructions (at least 250 MiB/sec of the decoding speed is delivered on a laptop that is used for development). Here you will also find a utility for generating disassembler/instruction…

postcard-rpc

A no_std + serde compatible RPC library for Rust

automotive_diag

Unified Diagnostic Services/UDS (ISO-14229-1), KWP2000 (ISO-142330) and OBD-II (ISO-9141) definitions to communicate with the road vehicle ECUs in Rust

stm32h7xx-hal

Hardware Abstraction Layer implementation for STM32H7 series microcontrollers

aht20-driver

Rust embedded-hal driver for the AHT20 temperature and humidity sensor

coap-lite

A lightweight CoAP message manipulation crate, ideal for embedded environments

device-driver

A toolkit to write better device drivers, faster

virtio-bindings

Rust FFI bindings to virtio generated using bindgen

trellis_m4

Board Support crate for the Adafruit NeoTrellis M4 Express

sbi-spec

Definitions and constants in the RISC-V Supervisor Binary Interface (RISC-V SBI)

statime

Precision Time Protocol implementation library for embedded and desktops

miniconf

Serialize/deserialize/access reflection for trees

jep106

A pollable collection of all JEP106 manufacturer codes

epd-waveshare

An embedded-hal based driver for ePaper displays from Waveshare formerly published as eink-waveshare-rs

rustc-build-sysroot

Build a rustc sysroot with custom flags

ufix

Flexible and usable generic fixed-point numeric type

delog

Deferred logging, an implementation and extension of Rust's standard logging facade

mos6502

A MOS 6502 Emulator

esp32-nimble

A wrapper for the ESP32 NimBLE Bluetooth stack

mavlink

Implements the MAVLink data interchange format for UAVs

fstr

A stack-allocated fixed-length string type

edge-dhcp

Async + no_std + no-alloc implementation of the DHCP protocol

s2json

supports the S2JSON 1.0 Specification

mustang

Rust programs written entirely in Rust

libc_alloc

global allocator which hooks into libc's malloc/free

littlefs2

Idiomatic Rust API for littlefs

rlsf

Real-time dynamic memory allocator based on the TLSF algorithm

bme280

device driver for the Bosch BME280 temperature, humidity, and atmospheric pressure sensor and the Bosch BMP280 temperature, and atmospheric pressure sensor

sbi

A pure-Rust library to interact with the RISC-V Supervisor Binary Interface

atsame54_xpro

Board Support crate for the SAM E54 Xplained Pro Evaluation Kit

rpsp

small, but extensible platform support package for RP2040 devices

buoyant

SwiftUI-like UIs in Rust for embedded devices

dlt-core

Parser and writer for autosar DLT Diagnostic Log and Trace

datasize

A simplified heap memory size estimator

cargo-dtc

Devicetree Compiler packaged for building with cargo

w5500

IoT Controller implementation

psx

developing homebrew for the Sony PlayStation 1

uwheel

Embeddable Aggregate Management System for Streams and Queries

tm1637-gpio-driver

Generic GPIO driver for the TM1637 micro controller, primarily for educational purpose. Doesn't need std-lib and you can choose any GPIO interface/library you want.

utralib

Xous UTRA (Unambiguous Thin Register Abstration) library generator

port-expander

Abstraction for I2C port-expanders

ina226-tp

Rust Driver for device INA226 High-Side or Low-Side Measurement, Bi-Direcional Current and Power Monitor

esp-wifi

A WiFi, Bluetooth and ESP-NOW driver for use with Espressif chips and bare-metal Rust

ravedude

easily flash code onto an AVR microcontroller with avrdude

embassy-futures

no-std, no-alloc utilities for working with futures

buddy-alloc

memory allocator for no-std Rust, used for embedded environments

interpn

N-dimensional interpolation/extrapolation methods, no-std and no-alloc compatible

sbat

UEFI Secure Boot Advanced Targeting (SBAT) no_std library

raki

RISC-V instruction decoder written in Rust

heretek

GDB TUI Dashboard for the understanding of vast knowledge

dfu-core

Sans IO core library (traits and tools) for DFU

rtsc

Real-time Synchronization Components

cmsis-pack

managing CMSIS Packs

edge-nal

Hosts a bunch of traits which are not yet available in the embedded-nal-async crate

rhai-dylib

Dylib support for Rhai

itm-parser

A command-line tool to parse and format ITM (Instrumentation Trace Macrocell) output for embedded systems development using probe-rs

aarch64-paging

manipulate AArch64 VMSA page tables

dcmimu

no_std DCM IMU implementation

static_cell

Statically allocated, initialized at runtime cell

biquad

digital second order IIR filtrers, also known as biquads

esp-println

print! and println! implementations various Espressif devices

efm32pg1b-pac

Peripheral access API for Silicon Labs EFM32PG1B microcontrollers

bluerobotics-ping

serves as the entry point for embedding applications using Rust on Blue Robotics's Ping devices family

ohos-drawing-sys

Bindings to the native_drawing API of OpenHarmony OS

teensy4-bsp

Rust-based BSP for the Teensy 4. Part of the teensy4-rs project

hx711_spi

A platform agnostic driver to interface with the HX711 using SPI

adafruit-seesaw

Platform-agnostic implementation for communicating with devices that run the Seesaw firmware

timerfd

interface to the Linux kernel's timerfd API

esp-at-nal

Network layer client for ESP-AT modems

morse-codec

live decoding and encoding of morse code messages. Supports multiple embedded devices and operating systems by being no_std.

windows_i686_gnu

Import lib for Windows

mimxrt685s-pac

Peripheral Access Crate for MIMXRT685s devices

ws2812-spi

SPI-based driver for ws2812 leds

va108xx

PAC for the Vorago VA108xx family of microcontrollers

embive

A lightweight, recoverable sandbox for executing untrusted RISC-V code in constrained environments (ex.: microcontrollers)

usbd-human-interface-device

Batteries included embedded USB HID library for usb-device. Includes concrete Keyboard (boot and NKRO), Mouse, Joystick and Consumer Control implementations as well as support for building your own HID classes.

gpt_disk_io

GPT (GUID Partition Table) disk IO no_std library

rppal

Interface for the Raspberry Pi's GPIO, I2C, PWM, SPI and UART peripherals

task-watchdog

A robust, flexible watchdog management library for embedded systems that multiplexes multiple task watchdogs into a single hardware watchdog timer, preventing system lockups when tasks fail to respond

map_vec

The Map and Set APIs backed by Vec

ihex

parsing and generating Intel HEX (or IHEX) objects. This format is commonly used for representing compiled program code and data to be loaded into a microcontroller, flash memory or ROM.

nrf-hal-common

details of the nRF HAL crates. Don’t use this directly, use one of the specific HAL crates instead (nrfXYZ-hal).

svdtools

modifying bugs in CMSIS SVD

os-terminal

Beautiful terminal emulator on no-std environment

jelly-mem_access

Memory Mapped I/O access library

float8

8-bit floating point types for Rust

mcan

Unofficial MCAN Hardware Abstraction Layer

nrf-modem

Async modem api for the nRF91xx

embedded-alloc

A heap allocator for embedded systems

thebakery

Build engine for the Yocto/OE Projects

nmea0183

NMEA 0183 parser targetting mostly embedded devices but not limited to

mpu6050-dmp

Platform-independent I2C driver for MPU6050. Supports DMP usage. Fork of drogue-mpu-6050 which uses only embedded-hal traits (no dependency on embedded-time or drogue-embedded-timer).

py32f0

Device support crates for PY32F0 devices

atomic-maybe-uninit

Atomic operations on potentially uninitialized integers

ws2812-esp32-rmt-driver

WS2812 driver using ESP32 RMT

wlink

WCH-Link flash tool for WCH's RISC-V MCUs(CH32V, CH56X, CH57X, CH58X, CH59X, CH32L103, CH32X035, CH641, CH643)

sbp-settings

SwiftNav settings API library

arm-gic

A driver for the Arm Generic Interrupt Controller version 2, 3 or 4

minimq

A minimal MQTT5 client designed for no_std platforms

avr-tester

Framework for testing AVR binaries

postcard-bindgen

generate bindings for the postcard binary format for other languages than Rust

autd3-link-soem

autd3 link using SOEM

aligned-array

A newtype with alignment of at least A bytes

max7800x-hal

A Hardware Abstraction Layer for the MAX7800X microcontroller family

cyclors

Low-level API for the native CycloneDDS bindings (libddsc-sys)

xmc4300

XMC peripheral library for XMC4300 generated from SVD

sgp30

Platform agnostic Rust driver for the Sensirion SGP30 gas sensor

hifmt

Format output without Rust code segment in binary to reduce the ultimate binary size

esp-idf-svc

embedded-svc traits for ESP-IDF (Espressif's IoT Development Framework)

embedded-aht20

Platform-agnostic Rust driver for the AHT20 temperature & humidity sensor

sen6x

no-std driver for the SEN6X sensor modules

nickel-lang-lsp

NLS: A language server for the Nickel configuration language

lis3dh-async

An embedded-hal-async driver for the LIS3DH accelerometer

nrf24-rs

Platform agnostic Rust driver for the nRF24L01 2.4 GHz transciever for wireless communication between embedded devices

fdt

A pure-Rust #![no_std] crate for parsing Flattened Devicetrees

iso7816

Types for ISO 7816

max7219

A platform agnostic driver to interface the MAX7219 (LED driver)

tinyrand

Lightweight RNG specification and several ultrafast implementations in Rust

u8g2-fonts

A text renderer for embedded-graphics, based on U8g2

c2a-core

Core of Command Centric Architecture

quadrature-decoder

Pure logic-level implementations of quadrature decoders with support for full-, half- an quad-stepping

lis2dh12

Platform-agnostic Rust driver for the LIS2DH12 accelerometer

scpi

SCPI/IEEE488.2 parser library

embedded-canvas

Draw anything with ease on the Canvas before drawing it to your small hardware display

redox-scheme

writing Redox scheme daemons

no_proto

Flexible, Fast & Compact Serialization with RPC

flat_device_tree

A pure-Rust #![no_std] crate for parsing Flattened Devicetrees

rusty_libimobiledevice

An ergonomic library to communicate with iOS devices

rustsbi

Minimal RISC-V's SBI implementation library in Rust

statig

Hierarchical state machines for designing event-driven systems

embedded-websocket

A lightweight websocket library for embedded systems (no_std)

bno055

Bosch Sensortec BNO055 9-axis IMU driver

regiface

ease development of interfacing with registers on embedded peripherals

azure_mgmt_baremetalinfrastructure

generated REST API bindings

bitbybit

Efficient implementation of bit-fields where several numbers are packed within a larger number and bit-enums. Useful for drivers, so it works in no_std environments

ushell

Embedded shell over serial connection

inky-frame

Driver and protocol library for InkyFrame devices with peripheral support

ellie_engine

Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments

ciborium-ll

Low-level CBOR codec primitives

windows_x86_64_gnullvm

Import lib for Windows

ioctl-sys

IO Control for POSIX-and-beyond systems (core fn & macros, see ioctls for many ioctl definitions)

embedded-sdmmc

A basic SD/MMC driver for Embedded Rust

radio

Generic traits for embedded packet radio devices

lsmtk

log-structured-merge-graph

svd-vector-gen

process Microcontroller SVD files(e.g. STM32) and generate vector tables and linker scripts.

lilos

A tiny embedded OS based around Futures and async

embedded-huffman

A paginated, streaming library for Huffman coding on embedded

embedded-dht-rs

A driver for interfacing with DHT11, DHT20 (AHT20), DHT22 (AM2302) temperature and humidity sensors, designed for embedded systems

embedded-iconoir

1300+ icons for embedded-graphics, ported from the Iconoir icon pack

gt911

An embedded touchscreen driver for GT911

tritium_remote

connecting to remote Robots running TritiumOS

voladdress

easy volatile memory abstraction

embedded-cli

CLI with autocompletion, help and history for embedded systems (like Arduino or STM32)

moondancer

firmware for the Great Scott Gadgets Cynthion USB Test Instrument

rotary-encoder-hal

platform agnostic rotary encoder library using embedded_hal

byte

A low-level, zero-copy and panic-free serializer and deserializer for binary

jetpwmon

Rust bindings for Jetson Power Monitor

asciidork-dr-html-backend

Asciidork Asciidoctor HTML backend

elf_loader

A pure-rust library for loading all ELF format files from both memory and files

astarte-device-sdk

that provides communication and pairing primitives to an Astarte Cluster

pic8259

Abstractions for the 8259 and 8259A interrupt controllers

embedded-test

A test harness and runner for embedded devices

strain

A CPU stressing utility written in Rust

tinywasm

A tiny WebAssembly interpreter

embedded-nal

A Network Abstraction Layer (NAL) for Embedded Systems

mplusfonts

Parametrized bitmap font family for embedded-graphics

bit-cursor

A cursor that supports bit-level reads and writes

dac8568

platform agnostic library for the Texas Instruments DAC8568, DAC8168 and DAC7568

a653rs

Arinc653 abstraction library for hypervisor independent partition programming

dot15d4

IEEE 802.15.4 implementation in Rust

garnish_lang_traits

Shared traits for garnish core libraries

codas

Compact and streamable data format that works anywhere--from web apps to robots

quadrature-encoder

Hardware-level implementations of drivers for incremental encoders with support for full-, half- an quad-stepping

fuchsia-zircon-sys

Types for low-level Rust bindings for the Zircon kernel

dht-pio

A DHT Implementation using PIO (Programmable Input/Output), tested on Rasberry Pi Pico

kble-eb90

Virtual Harness Toolkit

fixed32

Fixed Point types

shared-mem-queue

Single-writer single-reader queues which can be used for inter-processor-communication in a shared memory region

max78000-pac

A Peripheral Access Crate for the MAX78000 microcontroller

libdrm_amdgpu_sys

libdrm_amdgpu bindings for Rust, and some methods ported from Mesa3D

libosdp

IEC 60839-11-5 OSDP (Open Supervised Device Protocol)

terebinth

Lightweight, compiled programming language

include_data

Include typed data directly in your executable

libscd

Rust drivers for various SCD devices such as scd30 and scd4x CO2 sensors

nostd_structs

Datastructures and algorithms for nostd environments

vl53l0x

A platform agnostic driver to interface with the vl53l0x (time-to-flight sensor)

reqwless

HTTP client for embedded devices

usbd-dfu-rt

USB DFU run-time class

embedded-lora-rfm95

A no-std-compatible, opinionated driver for the RFM95 LoRa modem

bitfields

Macro for generating flexible bitfields. Useful for low-level code (embedded or emulators).

sht4x

Sensirion SHT4x Driver for Embedded HAL

singlevec

Vec-like container optimized for storing only a single item

lpc55-hal

Hardware Abstraction Layer (HAL) for the NXP LPC55S6x ARM Cortex-33 microcontrollers

kbuild

This package help you to build rust kernel quickly and easily

stateflow

extensible state machine implementation in Rust

elf2tab

Compiles from ELF to TAB (a Tock Application Bundle using the Tock Binary Format)

st7565

Driver for ST7565 based displays

mathx

A mathematics library designed to work with no_std

const-fnv1a-hash

A #![no_std] crate for performing FNV1A-16/32/64/128 hashing on Rust stable at compile time

embassy-stm32-plus

embassy-stm32 plus

stm32f4-staging

Device support crates for STM32F4 devices

arm-ffa

Arm Firmware Framework for Arm A-profile support library

fast-trap

Provide a framework for bare-metal trap handling, aiming at ensuring performance while reusing code

fixed-slice-vec

FixedSliceVec is a dynamic length Vec with runtime-determined maximum capacity backed by a slice

rttmon

RTT monitor for OpenOCD

fleetspeak

client connector library for the Rust language

tiny-varint

A no_std compatible VarInt encoding/decoding Rust library

svd-generator

Converts device information from flattened device tree into an SVD description

gc9a01-rs

SPI 4-wire driver for GC9A01 display controller

max11300

A rust-embedded driver for the MAX11300 ADC/DAC

embedded-sdmmc-dev

A basic SD/MMC driver for Embedded Rust

sx1262

A embedded-hal driver for the Semtech SX1261/2 sub-GHz radio transceiver

fdt-rs

A flattened device tree parser for embedded no-std environments

mcp2515

#![no_std] library for interacting with MCP2515 CAN controller chips

stm32_i2s_v12x

Driver for I2S communication (using SPI peripherals) for some STM32 microcontrollers

bmi088

6DOF IMU driver for embedded hal

dmx-rdm

communicating DMX512 (ANSI E1.11) and DMX-RDM (ANSI E1.20) over a RS485 bus by using interchangeable drivers

accelerometer

Generic, embedded-friendly accelerometer support, including traits and types for taking readings from 2 or 3-axis accelerometers and tracking device orientations

r2u2_core

R2U2: A stream-based runtime monitor in no_std

imxrt-hal

Hardware abstraction layer for NXP i.MX RT microcontrollers

j1939

SAE J1939 is a set of standards that define how ECUs communicate via the CAN bus in heavy-duty vehicles

mcp2003a

LIN transceiver driver with embedded-hal traits for no-std environments

pi_blocking_udp

mc-sst25

Microship SST25* flash memory series

sgp40

Rust driver for the Sensirion SGP40 gas sensor

lorawan

structures and tools for reading and writing LoRaWAN messages from and to a slice of bytes

dcf77_utils

DCF77 receiver for embedded platforms

safe-mmio

Types for safe MMIO device access, especially in systems with an MMU

drone-cortexm

ARM® Cortex®-M platform crate for Drone, an Embedded Operating System

cc2538-pac

Peripheral access API for CC2538 System-on-Chip

no-std-net

Rust's std::net... without the 'std'.

format-bytes

A macro to format bytestrings

it8951

E-Paper driver

fdt-parser

parsing FDT

bbqueue

A SPSC, lockless, no_std, thread safe, queue, based on BipBuffers

embassy-nrf

Embassy Hardware Abstraction Layer (HAL) for nRF series microcontrollers

is31fl3741

Driver for Lumissil Microsystem's IS31FL3741 IC

cargo-esp-new

A cargo-new extension for esp8266 chips

postcard-dyn

Dynamic ser/de for postcard

aps490_pfpu2_mini

Control software for PFPU2 automated brain detection system

rp235x-hal

Embeded-HAL impl for the RP2350 microcontroller

sht31

temperature and humidity sensor

oglo-cpu-asm

Official assembler implementation for Oglo CPU

format_no_std

Bare metal formatting

pac25

Device support crates for PAC25 devices

deploy-temp-fringe

safe, lightweight userland context switches

quectel-bg77

Driver for Quectel's BG77 and BG770 eMTC and NB-IoT Modems

lipl-display-egui

Displaying part on the screen using egui

disarmv7

Decodes armv7 instructions in to a rust enum

rt

A real-time operating system capable of full preemption

tatl

in-process alerting

numlang

A compiler for an esolang that uses hexadecimal

fixed_trigonometry

Fixed point numerical approimations to trigonometric functions

lcd1602-driver

A LCD1602 driver

w5500-hl

Driver for the Wiznet W5500 internet offload chip

machine-check-avr

formal verification of AVR microcontrollers by machine-check

usbd-midi

USB MIDI device class implementation for use with usb-device

at-commands

AT Commands builder and parser for Rust #![no_std]

flaw

Control-law-inspired embedded signal filtering, no-std and no-alloc compatible

linux-sysno

A list of system call numbers

std-embedded-nal

embedded-nal traits for large devices that support the standard library

micropb

Rust Protobuf library targetting embedded systems and no_std environments

ohrs

a cli tool for ohos-rs

avr-progmem

Progmem utilities for the AVR architectures

cs43l22-embedded

A cs43l22 DAC driver using embedded-hal

asahi-nvram

read and write nvram variables on ARM Macs

ug_max

Down-top left-right defined font. Seemly design for 5x5 display.

linux-embedded-hal

embedded-hal traits for Linux devices

ibm437

font for uses with the embedded-graphics crate

ls013b7dh03

Sharp LCD driver for embedded-hal

max6675-hal

An embedded-hal driver for the MAX6675 digital thermocouple converter

mips-rt

Minimal runtime for MIPS MCU cores

sensirion-i2c

Common functionality for I2C based sensors from Sensirion

piddiy

DIY custom PID controller toolkit

ili9341

A platform agnostic driver to interface with the ILI9341 (ald ILI9340C) TFT LCD display

bin_file

Mangling of various file formats that conveys binary information (Motorola S-Record, Intel HEX, TI-TXT and binary files)

ellie_core

Core modules for ellie

defmt-rtt

Transmit defmt log messages over the RTT (Real-Time Transfer) protocol

eva-common

Commons for EVA ICS v4

uln2003

28BYJ-48 stepper motor with and ULN2003 Driver on any hardware implementing embedded_hal

meshtastic

communicating with and configuring Meshtastic devices

wasefire-applet-api-desc

Description of the Wasefire applet API

nsw-types

Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…

embedded-nal-coap

A CoAP server and client implementation built on embedded-nal-async

loadcell

A no-std embedded-hal package for the hx711 load cell, based on the embedded hal. Has optional support for interrupts on the esp32.

typus_fugit

typenum powered time library for the embedded ecosystem

extargsparse_worker

Rust Commandline User Interface

timeslice

periodic time slice scheduler

xous-semver

porting semantic versions between build system and binary objects

rotary-encoder-embedded

A rotary-encoder library built with embedded-hal

esp-ota

Easy OTA updates for ESP32 chips using only safe Rust. Transport agnostic.

rpk-common

RPK common fields between config tool and firmware builder

noir_macros_core

Essential proc-macros and utilities for no_std Rust development

fh101rf

Driver crate for the FH101RF Wake-Up Radio

daisy

A board support package for the Electro-Smith Daisy Seed and Patch SM

flatipc

Zerocopy IPC between Xous clients and servers

buffered-io

Bufferering types for embedded-io

libarc2

Low-level interface library for ArC TWO™

ndless

interacting with Ndless for the TI-Nspire

faster-rs

Rust wrapper for FASTER by Microsoft Research

weather-utils

Set of common and useful weather-related computations

gd32f1x0-hal

HAL for the GD32F1x0 family of microcontrollers

rtic-sync

Synchronization primitives for asynchronous contexts

mitemp

Read Xiaomi MI Temperature and Humidity Sensor over BLE

serde_can

Convenient library for Serialize & deserialize CAN message

scd4x

Rust driver for the Sensirion SCD4x series. Carbon Dioxide / Temperature / Humidity sensors.

gpt-parser

GUID Partition Table (GPT) read-only parser. Endian aware and usable against no_std+alloc.

fixed32-math

Geometric types

memacc

Memory access functions

trapframe

Handle Trap Frame across kernel and user space on multiple ISAs