rigless 0.0.6

Virtual hardware-in-the-loop runtime: run unmodified firmware on an emulated MCU with every peripheral, chip model and unit of virtual time in Rust, and a fork of QEMU built in to execute the instructions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Copyright (c) 2026 Rigless Labs.
// SPDX-License-Identifier: MIT OR Apache-2.0
//! Blocks the processor architecture puts at a fixed address, rather than the part.
//!
//! A part's peripherals live beside the part, under [`crate::soc`], because the vendor decides which
//! exist and where. The processor brings its own, at addresses the architecture fixes: the same block
//! answers at the same address on every core of a family, whoever built the chip around it. Those live
//! here, one module per family, so a second part of the same family reaches them without copying.
//!
//! **A block here is a peripheral in every other respect.** It implements
//! [`Device`](crate::device::Device) against a register layout, it keeps its state in the register file,
//! it cites the manual by section, and the MCU holds it as a field like any other. What separates it is
//! only where it is written down and which manual it is written against.
//!
//! **The emulator answers this address space unless the machine says otherwise.** The processor's
//! own peripheral bus doesn't reach the runtime by default. The emulator implements the interrupt
//! controller and the system timer there and answers the rest itself, so a block modelled here is
//! reached only where the machine description claims its window. ADR-0024 is why, and what the
//! claim costs.

pub mod armv7m;