TinyOS — Ultraleichtes RTOS für IoT

Ein ultraleichtes Echtzeitbetriebssystem für ressourcenbeschränkte IoT- und eingebettete Geräte.
Kernel-Footprint unter 10 KB, 2 KB minimaler RAM, präemptives prioritätsbasiertes Scheduling.

Funktionen

Unterstützte Hardware

Schnellstart

Voraussetzungen```bash

ARM cross-compiler (required)

sudo apt-get install -y gcc-arm-none-eabi binutils-arm-none-eabi

QEMU ARM emulator (optional — for running without hardware)

sudo apt-get install -y qemu-system

Installation überprüfen:```bash
arm-none-eabi-gcc --version   # 10.x or later
qemu-system-arm --version     # 6.x or later

Erstellen```bash

Default example (blink_led) — ARM Cortex-M4

make

Target a different architecture (auto-selects toolchain and HAL)

make ARCH=cortex-m0 # Cortex-M0/M0+ make ARCH=cortex-m7 # Cortex-M7 make ARCH=riscv32 # RISC-V RV32I (uses riscv32-unknown-elf-gcc) make ARCH=avr5 # AVR ATmega (uses avr-gcc)

Specific example

make EXAMPLE=blink_led # LED blink + task scheduler demo make EXAMPLE=event_groups # Event group AND/OR/NOT/SYNC demo make EXAMPLE=iot_sensor # Multi-sensor IoT node make EXAMPLE=shell_demo # Interactive UART shell make EXAMPLE=mqtt_demo # MQTT publish/subscribe make EXAMPLE=condition_variable # Producer/consumer

Convenience aliases

make example-blink make example-events make example-shell make example-mqtt make example-iot

Build output

make size # Print ROM/RAM usage

Build-Artefakte werden in `build/` abgelegt:

| Datei | Beschreibung |
|---|---|
| `build/tinyos.elf` | ELF-Image mit Debug-Symbolen |
| `build/tinyos.bin` | Rohbinärdatei zum Flashen |
| `build/tinyos.map` | Linker-Map (Symbolgrößen) |

### Ausführen auf QEMU

TinyOS läuft auf dem QEMU `mps2-an385`-Ziel (ARM Cortex-M3, 4 MB Flash, 4 MB RAM):```bash
# Run indefinitely (Ctrl-A X to quit)
qemu-system-arm \
    -machine mps2-an385 \
    -cpu cortex-m3 \
    -nographic \
    -kernel build/tinyos.elf

# Run for a fixed duration (e.g. 10 seconds)
timeout 10 qemu-system-arm \
    -machine mps2-an385 \
    -cpu cortex-m3 \
    -nographic \
    -kernel build/tinyos.elf

# Debug: trace interrupts
qemu-system-arm \
    -machine mps2-an385 \
    -cpu cortex-m3 \
    -nographic \
    -d int \
    -kernel build/tinyos.elf

Die erwartete Ausgabe von der Interrupt-Trace: wiederholte successful exception return-Zeilen bestätigen, dass der Scheduler läuft, SysTick tickt und PendSV-Kontextwechsel sauber abgeschlossen werden.

Auf Hardware flashen```bash

OpenOCD (STM32 example)

openocd -f interface/stlink.cfg -f target/stm32f4x.cfg
-c "program build/tinyos.bin verify reset exit 0x08000000"

pyOCD (generic ARM Cortex-M)

pyocd flash --target cortex_m build/tinyos.bin

### Build mit TLS (mbedTLS)

TLS-Unterstützung wird automatisch aktiviert, wenn mbedTLS unter `~/mbedtls` vorhanden ist.
Um einen anderen Pfad zu verwenden:```bash
# Clone and build mbedTLS
git clone https://github.com/Mbed-TLS/mbedtls ~/mbedtls
make -C ~/mbedtls

# Build TinyOS with TLS
make MBEDTLS_DIR=~/mbedtls

Minimales Aufgabenbeispiel:```c #include "tinyos.h"

void my_task(void param) { while (1) { / work */ os_task_delay_ms(100); } }

int main(void) { tcb_t task; os_init(); os_task_create(&task, "my_task", my_task, NULL, PRIORITY_NORMAL); os_start(); }

---

## API-Übersicht

### Aufgabenverwaltung```c
os_task_create(tcb, name, entry, param, priority)
os_task_delete(task)
os_task_suspend(task) / os_task_resume(task)
os_task_delay(ticks) / os_task_delay_ms(ms)
os_task_set_priority(task, priority)
os_task_get_stats(task, stats)
os_task_get_stats_by_index(index, stats)   /* iterate all tasks by index */
os_task_find_by_name(name)                 /* returns tcb_t*, NULL if not found */
os_get_system_stats(stats)
os_get_memory_stats(&free, &used, &allocs, &frees)

Synchronisation```c

os_mutex_init(mutex) / os_mutex_lock(mutex, timeout) / os_mutex_unlock(mutex) os_semaphore_init(sem, count) / os_semaphore_wait(sem, timeout) / os_semaphore_post(sem) os_cond_init(cond) / os_cond_wait(cond, mutex, timeout) os_cond_signal(cond) / os_cond_broadcast(cond) os_event_group_set_bits(eg, bits) / os_event_group_wait_bits(eg, bits, opts, out, timeout) os_queue_init(q, buf, item_size, max) / os_queue_send(q, item, timeout) os_queue_receive(q, item, timeout) / os_queue_peek(q, item, timeout)

### Timer```c
os_timer_create(timer, name, type, period_ms, callback, param)
os_timer_start(timer) / os_timer_stop(timer) / os_timer_reset(timer)
os_timer_change_period(timer, ms) / os_timer_get_remaining_ms(timer)

Shell```c

/* Register custom commands before calling shell_start() */ shell_register_cmd(name, handler_fn, help_text)

/* Provide UART I/O callbacks and start the shell task */ shell_io_t io = { .getc = uart_getc, .puts = uart_puts }; shell_start(&io)

/* Change the prompt at any time */ shell_set_prompt("mydevice> ")

/* Execute a single line programmatically */ shell_exec(line)

**Beispiel für benutzerdefinierten Befehl:**```c
static int cmd_led(int argc, char *argv[]) {
    if (argc < 2) return 1;  /* non-zero → prints usage */
    bool on = (strcmp(argv[1], "on") == 0);
    gpio_write(LED_PIN, on);
    return 0;
}

/* In main(), before shell_start(): */
shell_register_cmd("led", cmd_led, "led <on|off>  Toggle LED");

Eingebaute Shell-Befehle

Tastenkombinationen des Zeileneditors:

Shell-Konfiguration (include/tinyos/shell.h):```c #define SHELL_MAX_COMMANDS 32 /* max registered commands / #define SHELL_LINE_MAX 128 / max input line length (bytes) / #define SHELL_ARGV_MAX 16 / max arguments per command / #define SHELL_HISTORY_DEPTH 8 / command history entries */

### Netzwerk```c
net_init(driver, config) / net_start()
net_socket(type) / net_bind(sock, addr) / net_connect(sock, addr, timeout_ms)
net_send(sock, data, len, timeout_ms) / net_recv(sock, buf, len, timeout_ms)
net_sendto(sock, data, len, addr) / net_recvfrom(sock, buf, len, addr)
net_close(sock)
net_ping(dest_ip, timeout_ms, rtt)
net_dns_resolve(hostname, ip, timeout_ms)
net_http_get(url, response, timeout_ms)
net_http_post(url, content_type, body, len, response, timeout_ms)

POSIX-Kompatibilität

TinyOS bietet zwei dünne Kompatibilitätsschichten, die es ermöglichen, standardmäßigen portablen Code mit minimalen Änderungen auf TinyOS zu kompilieren und auszuführen.

pthreads (include/tinyos/posix_threads.h)

Fügen Sie src/posix/posix_threads.c zu Ihrem Build hinzu.```c #include "tinyos/posix_threads.h"

/* ── Thread ── / pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); tinyos_pthread_attr_setpriority(&attr, PRIORITY_NORMAL); / TinyOS extension / pthread_create(&tid, &attr, my_fn, arg); pthread_join(tid, &retval); pthread_detach(tid); / free resources automatically on exit / pthread_exit(retval); / terminate calling thread / pthread_self(); / handle of calling thread */

/* ── Mutex ── / pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mtx); pthread_mutex_trylock(&mtx); / returns EBUSY if already locked */ pthread_mutex_unlock(&mtx);

/* ── Condition variable ── / pthread_cond_t cond = PTHREAD_COND_INITIALIZER; pthread_cond_wait(&cond, &mtx); pthread_cond_timedwait(&cond, &mtx, &abstime); / abstime relative to boot */ pthread_cond_signal(&cond); pthread_cond_broadcast(&cond);

| Konzept | Zugeordnet zu |
|---|---|
| `pthread_t` | Index in einen internen Pool von TinyOS `tcb_t`-Slots |
| `pthread_mutex_t` | Bettet `mutex_t` direkt ein (Zero-Init / `PTHREAD_MUTEX_INITIALIZER` gültig) |
| `pthread_cond_t` | Bettet `cond_var_t` direkt ein (Zero-Init / `PTHREAD_COND_INITIALIZER` gültig) |
| `pthread_join` | Wartet auf ein pro-Thread `semaphore_t`, das von `pthread_exit` gesendet wird |

**Nicht unterstützt:** `pthread_cancel`, Thread-lokaler Speicher (`pthread_key_*`),
rekursive Mutexe (gibt `ENOTSUP` zurück).

**Konfiguration** (`include/tinyos/posix_threads.h`):```c
#define PTHREAD_MAX_THREADS  MAX_TASKS  /* max concurrent pthreads */

BSD Sockets (include/tinyos/posix_socket.h)

Füge src/posix/posix_socket.c zu deinem Build hinzu.```c #include "tinyos/posix_socket.h"

/* ── TCP server ── */ int srv = socket(AF_INET, SOCK_STREAM, 0);

int reuse = 1; setsockopt(srv, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

struct sockaddr_in addr = { .sin_family = AF_INET, .sin_port = htons(8080), .sin_addr = { htonl(INADDR_ANY) }, }; bind(srv, (struct sockaddr *)&addr, sizeof(addr)); listen(srv, 4);

struct sockaddr_in peer; socklen_t plen = sizeof(peer); int client = accept(srv, (struct sockaddr )&peer, &plen); recv(client, buf, sizeof(buf), 0); send(client, response, response_len, 0); posix_sock_close(client); / or define TINYOS_POSIX_WRAP_CLOSE to use close() */ posix_sock_close(srv);

/* ── TCP client ── */ int fd = socket(AF_INET, SOCK_STREAM, 0); struct sockaddr_in dest = { .sin_family = AF_INET, .sin_port = htons(80), .sin_addr = { inet_addr("192.168.1.1") }, }; connect(fd, (struct sockaddr *)&dest, sizeof(dest)); send(fd, request, request_len, 0); recv(fd, buf, sizeof(buf), 0); posix_sock_close(fd);

/* ── UDP ── */ int udp = socket(AF_INET, SOCK_DGRAM, 0); sendto(udp, data, len, 0, (struct sockaddr *)&dest, sizeof(dest)); recvfrom(udp, buf, sizeof(buf), 0, (struct sockaddr *)&src, &srclen); posix_sock_close(udp);

/* ── Address utilities ── / htons(port) / htonl(addr) / ntohs(n) / ntohl(n) inet_addr("192.168.1.1") / → in_addr_t, network byte order / inet_ntoa(in) / → "192.168.1.1" (static buffer) */ inet_pton(AF_INET, "192.168.1.1", &in_addr) inet_ntop(AF_INET, &in_addr, buf, sizeof(buf))

| BSD-Aufruf | Zugeordnet zu |
|---|---|
| `socket()` | `net_socket()` |
| `bind()` | `net_bind()` |
| `listen()` | `net_listen()` |
| `accept()` | `net_accept()` |
| `connect()` | `net_connect()` |
| `send()` / `recv()` | `net_send()` / `net_recv()` |
| `sendto()` / `recvfrom()` | `net_sendto()` / `net_recvfrom()` |
| `posix_sock_close()` | `net_close()` |

**Unterstützte `setsockopt`-Optionen:**

| Option | Wirkung |
|---|---|
| `SO_REUSEADDR` | Akzeptiert; no-op (in TinyOS immer wiederverwendbar) |
| `SO_RCVTIMEO` | Setzt Empfangs-Timeout pro Socket (struct timeval → ms) |
| `SO_SNDTIMEO` | Setzt Sende-/Verbindungs-Timeout pro Socket |

**Umleitung von `close()`:** Definieren Sie `TINYOS_POSIX_WRAP_CLOSE` vor dem Einbinden des Headers, um `close(fd)` auf `posix_sock_close(fd)` abzubilden.

**Nicht unterstützt:** `select` / `poll` / `epoll`, nicht blockierender Modus (`O_NONBLOCK`), IPv6 (`AF_INET6` gibt `EAFNOSUPPORT` zurück).

---

### TLS / DTLS

TLS 1.2/1.3 über TCP und DTLS 1.2 über UDP, unterstützt durch **mbedTLS**.  
Aktivieren Sie zur Build-Zeit mit `-DTINYOS_TLS_ENABLE` und linken Sie gegen mbedTLS.```c
/* Client (TLS over TCP) */
tls_context_t tls;
tls_config_t  cfg = TLS_CONFIG_DEFAULT_CLIENT;
cfg.ca_cert     = ca_cert_pem;
cfg.ca_cert_len = sizeof(ca_cert_pem);
tls_init(&tls, &cfg);

net_socket_t sock = net_socket(SOCK_STREAM);
net_connect(sock, &broker_addr, 5000);
tls_connect(&tls, sock, "example.com", 5000);

tls_send(&tls, data, len);
tls_recv(&tls, buf, sizeof(buf), 5000);
tls_close(&tls);

/* Server (TLS accept) */
tls_config_t srv_cfg = TLS_CONFIG_DEFAULT_SERVER;
srv_cfg.cert     = server_cert_pem;
srv_cfg.cert_len = sizeof(server_cert_pem);
srv_cfg.key      = server_key_pem;
srv_cfg.key_len  = sizeof(server_key_pem);
tls_init(&tls, &srv_cfg);
tls_accept(&tls, client_sock, 5000);

/* DTLS over UDP */
tls_config_t dtls_cfg = TLS_CONFIG_DEFAULT_DTLS_CLIENT;
net_socket_t usock = net_socket(SOCK_DGRAM);
tls_connect_dtls(&tls, usock, "example.com", 5000);

MQTT

Vollständiges MQTT 3.1.1 mit QoS-Zustellgarantien pro Nachricht.```c mqtt_config_t cfg = { .broker_host = "mqtt.example.com", .client_id = "tinyos-01", .keepalive_sec = 60, .clean_session = true, .auto_reconnect = true, .reconnect_interval_ms = 3000, /* base; doubles each attempt (max 60 s) */ }; mqtt_client_t client; mqtt_client_init(&client, &cfg); mqtt_set_connection_callback(&client, on_connect, NULL); mqtt_set_message_callback(&client, on_message, NULL); mqtt_connect(&client);

/* Publish — QoS1/2 are buffered offline if disconnected */ mqtt_publish(&client, "sensors/temp", "23.5", 4, MQTT_QOS_1, false);

/* Inspect reliability queues / uint8_t in_flight = mqtt_get_inflight_count(&client); / sent, awaiting ACK / uint8_t pending = mqtt_get_pending_count(&client); / queued while offline */

mqtt_subscribe(&client, "cmd/#", MQTT_QOS_1); mqtt_flush_pending(&client); /* discard offline queue */ mqtt_disconnect(&client);

#### MQTT Zuverlässigkeitsmodell```
QoS 0  ─── fire-and-forget; dropped if disconnected
QoS 1  ─── in-flight table tracks each PUBLISH until PUBACK
              ↳ retransmits with DUP=1 every 5 s, up to 5 times
              ↳ if offline → offline queue (up to 8 messages)
QoS 2  ─── full PUBLISH → PUBREC → PUBREL → PUBCOMP handshake
              ↳ each step is retried independently on timeout

Auto-reconnect back-off: 3 s → 6 s → 12 s → … → 60 s (cap)
On reconnect: re-subscribes all topics, flushes offline queue

MQTT-Zuverlässigkeitskonfiguration (include/tinyos/mqtt.h):```c #define MQTT_MAX_INFLIGHT 8 /* in-flight slots / #define MQTT_MAX_PENDING 8 / offline queue slots / #define MQTT_MAX_PAYLOAD_SIZE 512 / bytes per queued msg / #define MQTT_RETRY_INTERVAL_MS 5000 / retry after (ms) / #define MQTT_MAX_RETRY_COUNT 5 / retries before drop / #define MQTT_RECONNECT_BASE_MS 3000 / first reconnect delay / #define MQTT_RECONNECT_MAX_MS 60000 / backoff ceiling */

### CoAP```c
coap_init(ctx, config, is_server) / coap_start(ctx) / coap_stop(ctx)
coap_get(ctx, ip, port, path, response, timeout_ms)
coap_post(ctx, ip, port, path, format, payload, len, response, timeout_ms)
coap_resource_create(ctx, path, handler, user_data)
coap_process(ctx, timeout_ms)

OTA```c

ota_init(config) ota_start_update(url, callback, user_data) ota_write_chunk(data, size, offset) / ota_finalize_update() ota_confirm_boot() / ota_rollback() ota_verify_partition(type)

### Dateisystem```c
fs_format(device) / fs_mount(device) / fs_unmount()
fs_open(path, flags) / fs_close(fd)
fs_read(fd, buf, size) / fs_write(fd, buf, size)
fs_seek(fd, offset, whence) / fs_tell(fd)
fs_mkdir(path) / fs_remove(path) / fs_rmdir(path)
fs_stat(path, stat)
fs_opendir(path) / fs_readdir(dir, entry) / fs_closedir(dir)
fs_get_stats(stats) / fs_get_free_space() / fs_is_mounted()

/* Copy-on-Write snapshots */
fs_snapshot(source_path, snapshot_name)   /* atomic COW snapshot of a file */
fs_get_block_refcount(block_nr)           /* reference count of a data block */

Journaling (Write-Ahead Log)

The filesystem uses metadata-only journaling (ordered mode). Before any inode, bitmap, or directory block is modified, a journal record is written to a dedicated 32-block WAL area at the start of the partition. On the next mount after a crash, fs_mount replays the journal and restores a consistent state.``` Disk layout (FS_BLOCK_SIZE = 512 bytes) Block 0 Superblock (version 0x00020000 — v2 with journaling) Block 1 Block bitmap Block 2 Journal header Blocks 3-33 Journal data (31 slots) Blocks 34-41 Inode table (8 blocks, 128 inodes) Block 42+ Data blocks

#### Copy-on-Write (COW)

Jeder Datenblock trägt einen im Speicher gehaltenen Referenzzähler, der aus der Inode-Tabelle beim Mounten wiederhergestellt wird.  Das Schreiben in einen Block, der gemeinsam genutzt wird (`refcount > 1`), weist zuerst eine private Kopie zu — der Zähler des Originalblocks wird dekrementiert und alle Änderungen finden am neuen Block statt.

`fs_snapshot()` erstellt einen atomaren Point-in-Time-Snapshot, indem die Quell-Inode (gleiche Blockzeiger, erhöhte Referenzzähler) innerhalb einer einzelnen Journal-Transaktion dupliziert wird.  Entweder wird der vollständige Snapshot festgeschrieben oder es ändert sich nichts.```c
/* Create a snapshot of /data/config → /snapshots/config-20260101 */
fs_snapshot("/data/config", "/snapshots/config-20260101");

/* Inspect sharing */
uint8_t rc = fs_get_block_refcount(42);   /* 1 = private, >1 = shared */

Energieverwaltung```c

os_power_init() os_power_set_mode(mode) /* ACTIVE / IDLE / SLEEP / DEEP_SLEEP */ os_power_get_mode() os_power_enter_sleep(duration_ms) os_power_enter_deep_sleep(duration_ms) os_power_enable_tickless_idle(enable) os_power_set_cpu_frequency(freq_hz) os_power_configure_wakeup(source, enable) os_power_get_stats(stats) os_power_get_consumption_mw() os_power_estimate_battery_life_hours()

### Watchdog```c
wdt_init(config) / wdt_start() / wdt_stop()
wdt_feed() / wdt_set_timeout(ms)
wdt_register_task(task, timeout_ms) / wdt_feed_task(task)

HAL (Hardwareabstraktionsschicht)

TinyOS bietet eine generische HAL, die den gesamten architekturspezifischen Registerzugriff hinter einer stabilen C-Schnittstelle verbirgt. Die Architektur wird zur Compile-Zeit über die ARCH-Makefile-Variable ausgewählt; in Kernel-Code tauchen keine #ifdef-Guards auf.

Portable Primitive (in jedem Arch-Header als static inline deklariert)```c

uint32_t hal_irq_save(void) /* disable IRQs, return saved state / void hal_irq_restore(uint32_t s) / restore IRQ state / void hal_context_switch_trigger() / pend PendSV / raise MSIP / Timer0 / void hal_cpu_wait_for_interrupt() / WFI / wfi / sleep instruction / void hal_cpu_dsb(void) / data synchronization barrier / void hal_cpu_isb(void) / instruction synchronization barrier */

#### Nicht-inline Funktionen (implementiert pro Architektur in `hal/<arch>/hal_<arch>.c`)```c
void     hal_init(void)
void     hal_tick_init(uint32_t core_clock_hz, uint32_t tick_rate_hz)
void     hal_tick_suppress(uint32_t max_ticks)
uint32_t hal_tick_unsuppress(void)
uint32_t hal_core_clock_hz(void)

bool     hal_cycle_counter_init(void)
void     hal_cycle_counter_reset(void)
uint32_t hal_cycle_counter_read(void)

bool     hal_mpu_init(uint8_t *region_count)
int      hal_mpu_configure_region(uint8_t region, uint32_t base,
                                   uint32_t size, uint32_t attrs)
void     hal_mpu_enable(bool allow_privileged_default)
void     hal_mpu_disable(void)

void     hal_irq_set_priority(int irq_num, uint8_t priority)
void     hal_system_reset(void)          /* does not return */
void     hal_fault_capture(const uint32_t *frame, hal_fault_info_t *info)

Plattform-Registrierung auf Board-Ebene

Registrieren Sie Board-Peripheriegeräte einmalig beim Start; der Kernel und der Energieverwalter fragen die Tabelle über hal_platform_get() ab, anstatt schwache Symbole zu verwenden.```c static const hal_uart_ops_t my_uart = { .init = ..., .putc = ... }; static const hal_power_ops_t my_power = { .enter_sleep = ..., .set_clock_hz = ... };

static const hal_platform_t board = { .uart[0] = &my_uart, .power = &my_power, };

hal_platform_register(&board); /* call before os_start() */

`hal_platform_t` stellt Slots für `uart[4]`, `flash`, `gpio`, `spi[4]`,
`i2c[4]` und `power` bereit. Ein `NULL`-Zeiger bedeutet „auf diesem Board nicht vorhanden".

#### Architektur-Unterstützungsmatrix

| Architektur | Tick-Quelle | Zykluszähler | MPU / PMP | Kontextwechsel-Auslöser |
|---|---|---|---|---|
| Cortex-M0/M0+/M3/M4/M7 | SysTick | DWT CYCCNT (M3+) | MPU | PendSV via ICSR |
| RISC-V RV32I/IM | CLINT MTIMECMP | `rdcycle` CSR | PMP (4 Regionen) | MSIP Software-Interrupt |
| AVR ATmega/ATtiny | Timer0 CTC | — (gibt 0 zurück) | — | Timer0-Überlauf |

---

## Konfiguration

**`include/tinyos.h`** — Kernel und Betriebssystem:```c
#define MAX_TASKS              16     /* max concurrent tasks                    */
#define STACK_SIZE             256    /* stack size per task (words)             */
#define TICK_RATE_HZ           1000   /* scheduler tick frequency (Hz)           */
#define TIME_SLICE_MS          10     /* round-robin time slice (ms)             */
#define TICKLESS_MAX_SLEEP_TICKS 100U /* tickless idle: max ticks per WFI sleep  */

include/tinyos/shell.h — interaktive Shell:```c #define SHELL_MAX_COMMANDS 32 /* max registered commands / #define SHELL_LINE_MAX 128 / max input line length (bytes) / #define SHELL_ARGV_MAX 16 / max arguments per command / #define SHELL_HISTORY_DEPTH 8 / command history ring buffer */

**`include/tinyos/mqtt.h`** — MQTT-Zuverlässigkeit:```c
#define MQTT_MAX_INFLIGHT        8      /* in-flight QoS1/2 slots    */
#define MQTT_MAX_PENDING         8      /* offline queue slots       */
#define MQTT_MAX_PAYLOAD_SIZE    512    /* max queued payload bytes  */
#define MQTT_RETRY_INTERVAL_MS   5000   /* unACKed retry interval    */
#define MQTT_MAX_RETRY_COUNT     5      /* retries before discard    */
#define MQTT_RECONNECT_BASE_MS   3000   /* initial reconnect delay   */
#define MQTT_RECONNECT_MAX_MS    60000  /* back-off ceiling          */

TLS — erfordert mbedTLS; aktivieren mit:```makefile CFLAGS += -DTINYOS_TLS_ENABLE LDFLAGS += -lmbedtls -lmbedcrypto -lmbedx509

---

## Projektstruktur```
tinyos-rtos/
├── include/
│   ├── tinyos.h              # Core API (tasks, sync, timers, memory, FS, power)
│   └── tinyos/
│       ├── shell.h           # Interactive shell API & configuration
│       ├── net.h             # Network stack
│       ├── tls.h             # TLS 1.2/1.3 + DTLS 1.2 (mbedTLS)
│       ├── mqtt.h            # MQTT 3.1.1 client
│       ├── coap.h            # CoAP RFC 7252
│       ├── ota.h             # OTA firmware updates
│       ├── watchdog.h        # Watchdog timer
│       ├── posix_threads.h   # POSIX pthreads compatibility layer
│       └── posix_socket.h    # BSD socket compatibility layer
├── src/
│   ├── startup.s             # Vector table, Reset_Handler, SysTick/SVC/PendSV stubs
│   ├── context_switch.s      # Thumb-2: PendSV_Handler, SVC_Handler, os_pend_sv
│   ├── kernel.c              # Preemptive scheduler & task management
│   ├── sync.c                # Mutex, semaphore, queue, condition var, event groups
│   ├── timer.c               # Software timers
│   ├── memory.c              # Heap allocator
│   ├── shell.c               # Interactive shell (VT100, history, tab completion)
│   ├── filesystem.c          # Block-device file system
│   ├── security.c            # MPU memory protection
│   ├── power.c               # Power management & CPU frequency scaling
│   ├── watchdog.c            # Watchdog (HW + SW, per-task monitoring)
│   ├── bootloader.c          # Secure bootloader
│   ├── ota.c                 # OTA A/B partition updates
│   ├── mqtt.c                # MQTT client (in-flight table, offline queue)
│   ├── coap.c                # CoAP client/server
│   ├── net/
│   │   ├── network.c         # Core & buffer management
│   │   ├── ethernet.c        # Ethernet / ARP
│   │   ├── ip.c              # IPv4 / ICMP
│   │   ├── socket.c          # UDP / TCP socket API
│   │   ├── http_dns.c        # HTTP client & DNS resolver
│   │   └── tls.c             # TLS/DTLS (mbedTLS wrapper, excluded when mbedTLS absent)
│   └── posix/
│       ├── posix_threads.c   # pthreads → TinyOS task/sync wrapper
│       └── posix_socket.c    # BSD socket → net_* wrapper
├── hal/
│   ├── hal.h                 # Portable HAL interface (arch-agnostic API + peripheral op-tables)
│   ├── cortex_m/
│   │   ├── hal_cortex_m.h    # Register defines + static inline primitives (irq_save, WFI, DSB …)
│   │   └── hal_cortex_m.c    # SysTick, DWT, MPU, AIRCR reset, fault capture
│   ├── riscv/
│   │   ├── hal_riscv.h       # csrrci/csrw inline primitives, CLINT defines
│   │   └── hal_riscv.c       # CLINT tick, rdcycle counter, PMP, PLIC priority, CSR fault capture
│   └── avr/
│       ├── hal_avr.h         # SREG-based irq_save, Timer0 context-switch trigger
│       └── hal_avr.c         # Timer0 CTC tick, watchdog reset, stub MPU/cycle-counter
├── drivers/
│   ├── flash.c / flash.h     # Flash memory driver
│   ├── ramdisk.c / ramdisk.h # RAM disk (testing)
│   └── loopback_net.c        # Loopback network driver (testing)
├── linker.ld                 # Linker script (mps2-an385: Flash 0x0/4MB, RAM 0x20000000/4MB)
└── examples/
    ├── blink_led.c           # GPIO blink
    ├── iot_sensor.c          # Multi-task sensor node
    ├── shell_demo.c          # Custom shell commands over UART
    ├── network_demo.c        # TCP/UDP/HTTP/ping
    ├── tls_demo.c            # TLS client/server
    ├── mqtt_demo.c           # MQTT publish/subscribe (QoS 1/2)
    ├── coap_demo.c           # CoAP client/server
    ├── ota_demo.c            # Firmware update flow
    ├── filesystem_demo.c     # File I/O
    ├── watchdog_demo.c       # Watchdog configuration
    ├── low_power.c           # Power mode transitions
    ├── software_timers.c     # Timer creation and callbacks
    ├── event_groups.c        # Event synchronisation
    ├── event_flags_logic.c   # AND / OR / NOT(CLEAR) / SYNC(barrier) patterns
    ├── condition_variable.c  # Producer/consumer
    ├── priority_adjustment.c # Dynamic priority
    ├── task_statistics.c     # CPU and stack monitoring
    └── posix_compat_demo.c   # POSIX pthreads + socket usage examples

Leistung

Systemanforderungen: 2 KB RAM Minimum · < 10 KB ROM für den Kernel allein

Änderungsprotokoll

v2.0.0

Neue Funktionen

• Journaling-Dateisystem (src/filesystem.c) — Write-Ahead Log (WAL) schützt alle Metadaten-Schreibvorgänge (Inodes, Bitmap, Superblock, Verzeichnisse). Das On-Disk-Format wurde auf FS_VERSION 0x00020000 erhöht. Das Journal belegt 32 Blöcke beginnend bei Block 2; fs_mount spielt jede festgeschriebene, aber noch nicht angewandte Transaktion ab, bevor die Kontrolle an die Anwendung übergeben wird. Reine Metadaten-Journaling (ordered) hält die Write-Amplification niedrig und garantiert ein konsistentes Dateisystem nach einem Stromausfall oder Reset zu jedem Zeitpunkt während eines Schreibvorgangs.

• Copy-on-Write-Blockfreigabe (src/filesystem.c) — Jeder Datenblock trägt einen In-Memory-Referenzzähler (wird beim Einhängen aus der Inode-Tabelle neu aufgebaut). Das Schreiben in einen gemeinsam genutzten Block weist stillschweigend eine private Kopie zu; der Zähler des gemeinsamen Blocks wird dekrementiert. fs_snapshot(source, name) erstellt eine atomare Point-in-Time-Snapshot innerhalb einer einzigen Journal-Transaktion — entweder alles oder nichts wird festgeschrieben. Neue öffentliche API: fs_snapshot() und fs_get_block_refcount() (siehe include/tinyos.h).

• Generisches HAL (hal/) — Eine zweistufige Hardware-Abstraktionsschicht entkoppelt den Kernel von ARM-Cortex-M-spezifischem Assembler.

Brechende Änderungen

• src/kernel.c enthält keine rohen SYST_*, SCB_SHPR3, SCB_AIRCR oder DWT_*-Registerdefinitionen mehr — diese werden jetzt vom HAL bereitgestellt. Code, der diese Makros direkt referenziert hat, muss aktualisiert werden, um die HAL-API zu verwenden.
• src/power.c-Weak-Symbole (platform_enter_sleep_mode usw.) delegieren jetzt an hal_platform_t->power, wenn eine Plattform registriert ist; Boards, die auf den alten __asm__ volatile("wfi")-Standardwert vertraut haben, sehen identisches Verhalten, es sei denn, eine hal_power_ops_t wird registriert.
• Die Dateisystem-On-Disk-Version ist 0x00020000. Volumes, die mit v1.x formatiert wurden, müssen neu formatiert werden (fs_format).

v1.2.0

Fehlerbehebungen

• startup.s-Vektortabelle — MemManage_Handler, BusFault_Handler und UsageFault_Handler zeigen jetzt auf die korrekten Handler in fault.c. Zuvor lösten alle drei Einträge auf Default_Handler auf, sodass MPU-, Bus- und Usage-Faults stillschweigend verschluckt wurden, anstatt die Diagnoseausgabe auszulösen.
• os_cond_wait-Doppeldekrement — cond_remove_task() dekrementiert bereits waiting_count; die drei Aufrufstellen, die es danach erneut dekrementierten, wurden korrigiert. Zuvor konnte ein zusätzlicher ungewollter Dekrement den Zähler unterlaufen lassen und den Zustand der Bedingungsvariable beschädigen.
• Mutex-PIP-Boost nicht bei Timeout aufgehoben — der zeitgesteuerte Spin-Pfad in os_mutex_lock ruft jetzt mutex_pip_recalculate() auf, bevor er OS_ERROR_TIMEOUT zurückgibt. Zuvor wurde der dem Besitzer gewährte Prioritätsboost nie rückgängig gemacht, wenn die wartende Task aufgab, was zu einer permanenten Prioritätsinflation führte.

Verbesserungen

• Neuschreibung des Speicher-Allokators (src/memory.c) — ersetzt den festen 32-Byte-Block-Pool durch einen First-Fit-Allokator mit:
  • 8 KB Heap (zuvor 4 KB), 8-Byte-ausgerichtete Blöcke
  • Freiliste nach Adressen sortiert; benachbarte freie Blöcke werden sofort bei jedem os_free() (vorwärts und rückwärts) zusammengeführt
  • Blöcke werden bei der Allokation geteilt, wenn der Rest groß genug ist, um nützlich zu sein (≥ BLK_HDR + ALIGN)
• os_init()-Initialisierungsreihenfolge — os_mem_init() und os_power_init() werden jetzt vor os_timer_init() aufgerufen, sodass Heap und Power-Subsystem bereit sind, bevor Timer-Callbacks oder Task-Code ausgeführt werden.
• Tickless-Idle implementiert (src/kernel.c: os_kernel_tickless_sleep) — wenn über os_power_enable_tickless_idle(true) aktiviert, unterdrückt die Idle-Task den SysTick vor WFI und verwendet den DWT-CYCCNT-Zykluszähler, um die tatsächlich vergangene Zeit zu messen. Nach dem Aufwachen wird SysTick neu gestartet, wird um die gemessenen Ticks erhöht (begrenzt auf ), und wird aufgerufen, um überfällige Tasks sofort zu entsperren. Zuvor existierte das Flag, aber der Idle-Pfad fiel immer auf ein einfaches mit laufendem SysTick zurück.

v1.1.0

Neue Funktionen

• EVENT_WAIT_CLEAR-Flag für Ereignisgruppen — warten, bis Bits gelöscht sind (NOT-Bedingung). EVENT_WAIT_ALL | EVENT_WAIT_CLEAR wird wach, wenn alle maskierten Bits 0 sind; EVENT_WAIT_ANY | EVENT_WAIT_CLEAR wird wach, wenn irgendeines 0 ist.
• os_event_group_sync() — Rendezvous-/Barriere-Primitiv. Jede teilnehmende Task setzt ihr eigenes Ankunftsbit und blockiert, bis der vollständige Satz vorhanden ist; alle werden gleichzeitig entsperrt.
• Neues Beispiel examples/event_flags_logic.c, das alle vier Modi (AND, OR, NOT, SYNC) demonstriert.

Build- und Laufzeitkorrekturen

• src/startup.s hinzugefügt: Vektortabelle, Reset_Handler (.data-Kopie, .bss-Nullsetzung), SysTick_Handler-Stub, HardFault_Handler.
• linker.ld hinzugefügt: Speicherlayout für mps2-an385 (Flash 0x00000000/4 MB, RAM 0x20000000/4 MB).
• Initialer Task-Stack korrigiert: Der R4–R11-Speicherbereich wird jetzt vorab alloziert, sodass LDMIA {R4-R11} von PendSV beim ersten Kontextwechsel in jeden neu erstellten Task korrekt funktioniert.
• SVC_Handler aktualisiert auf LDMIA {R4-R11} vor dem Setzen von PSP, sodass SVC- und PendSV-Pfade symmetrisch sind.
• MPU_TYPE-Prüfung in os_mpu_configure_default() — MPU-Einrichtung wird stillschweigend übersprungen, wenn keine MPU vorhanden ist (QEMU ).

Lizenz

MIT-Lizenz — siehe LICENSE für Details.