TinyOS — IoT के लिए अल्ट्रा-लाइटवेट RTOS

एक अति-हल्का रियल-टाइम ऑपरेटिंग सिस्टम जो संसाधन-सीमित IoT और एम्बेडेड उपकरणों के लिए है।
कर्नेल फुटप्रिंट 10 KB से कम, न्यूनतम RAM 2 KB, प्रीएम्प्टिव प्रायोरिटी-आधारित शेड्यूलिंग।

विशेषताएँ

समर्थित हार्डवेयर

त्वरित आरंभ

पूर्वापेक्षाएँ```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

स्थापना की पुष्टि करें:```bash
arm-none-eabi-gcc --version   # 10.x or later
qemu-system-arm --version     # 6.x or later

निर्माण```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/` में रखे गए हैं:

| फ़ाइल | विवरण |
|---|---|
| `build/tinyos.elf` | ELF इमेज जिसमें डीबग सिंबल हैं |
| `build/tinyos.bin` | फ्लैशिंग के लिए रॉ बाइनरी |
| `build/tinyos.map` | लिंकर मैप (सिंबल आकार) |

### QEMU पर चलाएँ

TinyOS QEMU `mps2-an385` टार्गेट (ARM Cortex-M3, 4 MB फ्लैश, 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

हार्डवेयर में फ्लैश करें

इंटरप्ट ट्रेस से अपेक्षित आउटपुट: repeated successful exception return पंक्तियाँ पुष्टि करती हैं कि शेड्यूलर चल रहा है, SysTick टिक कर रहा है, और PendSV कॉन्टेक्स्ट स्विच स्वच्छ रूप से पूर्ण हो रहे हैं।```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

### TLS (mbedTLS) के साथ बनाएँ

TLS समर्थन स्वचालित रूप से सक्षम होता है जब mbedTLS `~/mbedtls` पर मौजूद होता है।
एक अलग पथ का उपयोग करने के लिए:```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

न्यूनतम कार्य उदाहरण:```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 अवलोकन

### कार्य प्रबंधन```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)

सिंक्रनाइज़ेशन```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)

### टाइमर```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)

शेल```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)

**कस्टम कमांड उदाहरण:**```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");

बिल्ट-इन शैल कमांड

लाइन एडिटर कुंजी बाइंडिंग:

शैल कॉन्फ़िगरेशन (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 */

### नेटवर्क```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 अनुकूलता

TinyOS दो पतली अनुकूलता परतें प्रदान करता है जो मानक पोर्टेबल कोड को न्यूनतम परिवर्तनों के साथ TinyOS पर संकलित और चलाने की अनुमति देती हैं।

pthreads (include/tinyos/posix_threads.h)

अपने बिल्ड में src/posix/posix_threads.c जोड़ें।```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);

| अवधारणा | मैप किया गया |
|---|---|
| `pthread_t` | TinyOS के `tcb_t` स्लॉट्स के आंतरिक पूल में इंडेक्स |
| `pthread_mutex_t` | `mutex_t` को सीधे एम्बेड करता है (zero-init / `PTHREAD_MUTEX_INITIALIZER` मान्य) |
| `pthread_cond_t` | `cond_var_t` को सीधे एम्बेड करता है (zero-init / `PTHREAD_COND_INITIALIZER` मान्य) |
| `pthread_join` | प्रति-थ्रेड `semaphore_t` पर प्रतीक्षा करता है, जो `pthread_exit` द्वारा पोस्ट किया गया है |

**समर्थित नहीं है:** `pthread_cancel`, थ्रेड-लोकल स्टोरेज (`pthread_key_*`),
रिकर्सिव म्यूटेक्स (`ENOTSUP` लौटाता है)।

**कॉन्फ़िगरेशन** (`include/tinyos/posix_threads.h`):```c
#define PTHREAD_MAX_THREADS  MAX_TASKS  /* max concurrent pthreads */

BSD Sockets (include/tinyos/posix_socket.h)

अपने बिल्ड में src/posix/posix_socket.c जोड़ें।```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 कॉल | मैप किया गया |
|---|---|
| `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()` |

**समर्थित `setsockopt` विकल्प:**

| विकल्प | प्रभाव |
|---|---|
| `SO_REUSEADDR` | स्वीकार किया गया; कोई क्रिया नहीं (TinyOS में हमेशा पुन: प्रयोज्य) |
| `SO_RCVTIMEO` | प्रति सॉकेट रिसीव टाइमआउट सेट करता है (struct timeval → ms) |
| `SO_SNDTIMEO` | प्रति सॉकेट भेजने/कनेक्ट टाइमआउट सेट करता है |

**`close()` पुनर्निर्देशन:** `TINYOS_POSIX_WRAP_CLOSE` को हेडर शामिल करने से पहले परिभाषित करें ताकि `close(fd)` → `posix_sock_close(fd)` मैप हो सके।

**समर्थित नहीं:** `select` / `poll` / `epoll`, गैर-अवरोधक मोड (`O_NONBLOCK`), IPv6 (`AF_INET6` `EAFNOSUPPORT` लौटाता है)।

---

### TLS / DTLS

TCP पर TLS 1.2/1.3 और UDP पर DTLS 1.2, **mbedTLS** द्वारा समर्थित।  
बिल्ड समय पर `-DTINYOS_TLS_ENABLE` के साथ सक्षम करें और 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

पूर्ण MQTT 3.1.1 प्रति-संदेश QoS डिलीवरी गारंटी के साथ।```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 विश्वसनीयता मॉडल```
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 विश्वसनीयता कॉन्फ़िगरेशन (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)

### फ़ाइल सिस्टम```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 */

जर्नलिंग (राइट-अहेड लॉग)

फ़ाइलसिस्टम केवल-मेटाडेटा जर्नलिंग (क्रमबद्ध मोड) का उपयोग करता है। किसी भी inode, बिटमैप, या निर्देशिका ब्लॉक को संशोधित करने से पहले, एक जर्नल रिकॉर्ड विभाजन की शुरुआत में स्थित समर्पित 32-ब्लॉक WAL क्षेत्र में लिखा जाता है। क्रैश के बाद अगली माउंट पर, fs_mount जर्नल को रीप्ले करता है और एक सुसंगत स्थिति को पुनर्स्थापित करता है।``` 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)

प्रत्येक डेटा ब्लॉक एक इन-मेमोरी संदर्भ गणना करता है जो माउंट समय पर इनोड तालिका से पुनर्निर्मित होती है। एक साझा ब्लॉक (`refcount > 1`) में लिखने पर पहले एक निजी प्रतिलिपि आवंटित की जाती है — मूल ब्लॉक की गणना घटा दी जाती है और सभी परिवर्तन नए ब्लॉक पर होते हैं।

`fs_snapshot()` एक परमाणु बिंदु-इन-टाइम स्नैपशॉट बनाता है, जो स्रोत इनोड (समान ब्लॉक पॉइंटर्स, बढ़ी हुई refcounts) की नकल करके एकल जर्नल लेनदेन के अंतर्गत होता है। या तो पूरा स्नैपशॉट प्रतिबद्ध होता है या कुछ भी नहीं बदलता।```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 */

शक्ति प्रबंधन```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()

### निगरानी```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 (हार्डवेयर एब्स्ट्रैक्शन लेयर)

TinyOS एक सामान्य HAL प्रदान करता है जो सभी आर्किटेक्चर-विशिष्ट रजिस्टर एक्सेस को एक स्थिर C इंटरफेस के पीछे छिपा देता है। आर्किटेक्चर को कंपाइल समय पर ARCH Makefile वेरिएबल के माध्यम से चुना जाता है; कर्नेल कोड में कोई #ifdef गार्ड नहीं दिखता।

पोर्टेबल प्रिमिटिव्स (प्रत्येक आर्क हेडर में static inline घोषित)```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 */

#### गैर-इनलाइन फ़ंक्शन (प्रति आर्क में लागू `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)

बोर्ड-स्तरीय प्लेटफ़ॉर्म रजिस्ट्री

स्टार्टअप पर एक बार बोर्ड परिधीयों को पंजीकृत करें; कर्नेल और पावर मैनेजर कमजोर प्रतीकों का उपयोग करने के बजाय hal_platform_get() के माध्यम से तालिका को क्वेरी करते हैं।```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` `uart[4]`, `flash`, `gpio`, `spi[4]`, `i2c[4]`, और `power` के लिए स्लॉट प्रदान करता है। कोई भी `NULL` पॉइंटर का अर्थ है "इस बोर्ड पर मौजूद नहीं"।

#### आर्किटेक्चर समर्थन मैट्रिक्स

| आर्किटेक्चर | टिक स्रोत | चक्र काउंटर | MPU / PMP | कॉन्टेक्स्ट स्विच ट्रिगर |
|---|---|---|---|---|
| Cortex-M0/M0+/M3/M4/M7 | SysTick | DWT CYCCNT (M3+) | MPU | PendSV via ICSR |
| RISC-V RV32I/IM | CLINT MTIMECMP | `rdcycle` CSR | PMP (4 regions) | MSIP software interrupt |
| AVR ATmega/ATtiny | Timer0 CTC | — (returns 0) | — | Timer0 overflow |

---

## कॉन्फ़िगरेशन

**`include/tinyos.h`** — कर्नेल और OS:```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 — इंटरैक्टिव शेल:```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 विश्वसनीयता:```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 — mbedTLS की आवश्यकता है; इसके साथ सक्षम करें:```makefile CFLAGS += -DTINYOS_TLS_ENABLE LDFLAGS += -lmbedtls -lmbedcrypto -lmbedx509

---

## परियोजना संरचना```
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

प्रदर्शन

सिस्टम आवश्यकताएँ: न्यूनतम 2 KB RAM · कर्नेल के लिए < 10 KB ROM

चेंजलॉग

v2.0.0

नई सुविधाएँ

• जर्नलिंग फाइलसिस्टम (src/filesystem.c) — राइट-अहेड लॉग (WAL) सभी मेटाडेटा राइट (इनोड, बिटमैप, सुपरब्लॉक, डायरेक्टरी) की सुरक्षा करता है। ऑन-डिस्क फ़ॉर्मेट को FS_VERSION 0x00020000 तक बढ़ा दिया गया है। जर्नल ब्लॉक 2 से शुरू होने वाले 32 ब्लॉक घेरता है; fs_mount एप्लिकेशन को नियंत्रण सौंपने से पहले किसी भी कमिटेड लेकिन अनलागू लेन-देन को रीप्ले करता है। मेटाडेटा-केवल (ऑर्डर्ड) जर्नलिंग राइट एम्प्लीफिकेशन को कम रखता है, जबकि लिखने के दौरान किसी भी बिंदु पर बिजली की विफलता या रीसेट के बाद एक सुसंगत फाइलसिस्टम की गारंटी देता है।

• कॉपी-ऑन-राइट ब्लॉक शेयरिंग (src/filesystem.c) — प्रत्येक डेटा ब्लॉक एक इन-मेमोरी रेफरेंस काउंट (माउंट समय पर इनोड टेबल से पुनर्निर्मित) रखता है। किसी साझा ब्लॉक में लिखने पर स्वचालित रूप से एक निजी प्रतिलिपि आवंटित होती है; साझा ब्लॉक की गणना घटा दी जाती है। fs_snapshot(source, name) एकल जर्नल लेन-देन के अंदर एक परमाणु समय-बिंदु स्नैपशॉट बनाता है — या तो पूरी तरह से या कुछ भी कमिट नहीं होता। नया सार्वजनिक API: fs_snapshot() और fs_get_block_refcount() (include/tinyos.h देखें)।

• जेनेरिक HAL (hal/) — एक दो-स्तरीय हार्डवेयर एब्स्ट्रैक्शन लेयर कर्नेल को ARM Cortex-M-विशिष्ट असेंबली से अलग करता है।

ब्रेकिंग चेंजेज

• src/kernel.c में अब नंगे SYST_*, SCB_SHPR3, SCB_AIRCR, या DWT_* रजिस्टर डिफाइन नहीं हैं — ये अब HAL द्वारा प्रदान किए जाते हैं। वह कोड जो सीधे इन मैक्रोज़ को संदर्भित करता है, उसे HAL API का उपयोग करने के लिए अपडेट किया जाना चाहिए।
• src/power.c कमज़ोर प्रतीक (platform_enter_sleep_mode, आदि) अब जब कोई प्लेटफ़ॉर्म पंजीकृत होता है तो hal_platform_t->power को डेलिगेट करते हैं; जो बोर्ड पुराने __asm__ volatile("wfi") डिफ़ॉल्ट पर निर्भर थे, वे समान व्यवहार देखेंगे जब तक कि hal_power_ops_t पंजीकृत न हो।
• फाइलसिस्टम ऑन-डिस्क वर्ज़न 0x00020000 है। v1.x के साथ फॉर्मेट किए गए वॉल्यूम को पुन: स्वरूपित किया जाना चाहिए (fs_format)।

v1.2.0

बग फिक्स

• startup.s वेक्टर टेबल — MemManage_Handler, BusFault_Handler, और UsageFault_Handler अब fault.c में सही हैंडलर की ओर इशारा करते हैं। पहले तीनों प्रविष्टियाँ Default_Handler को हल करती थीं, इसलिए MPU, बस और उपयोग दोष चुपचाप निगल लिए जाते थे, डायग्नोस्टिक डंप को ट्रिगर करने के बजाय।
• os_cond_wait डबल-डिक्रीमेंट — cond_remove_task() पहले से ही waiting_count को घटाता है; तीन कॉल साइटों को ठीक कर दिया गया है जो इसके बाद इसे फिर से घटाती थीं। पहले एक स्प्यूरियस अतिरिक्त डिक्रीमेंट काउंटर को अंडरफ़्लो कर सकता था और कंडीशन वेरिएबल स्थिति को दूषित कर सकता था।
• Mutex PIP बूस्ट टाइमआउट पर जारी नहीं होता — os_mutex_lock में टाइम्ड स्पिन पथ अब OS_ERROR_TIMEOUT लौटाने से पहले mutex_pip_recalculate() कॉल करता है। पहले स्वामी पर लागू प्राथमिकता बूस्ट कभी पूर्ववत नहीं होता था जब प्रतीक्षा कार्य ने हार मान ली थी, जिससे स्थायी प्राथमिकता मुद्रास्फीति होती थी।

सुधार

• मेमोरी आवंटनकर्ता पुनर्लेखन (src/memory.c) — निश्चित 32-बाइट ब्लॉक पूल को एक प्रथम-फिट आवंटनकर्ता से बदल दिया गया जिसमें शामिल हैं:
  • 8 KB हीप (4 KB से ऊपर), 8-बाइट संरेखित ब्लॉक
  • फ्री लिस्ट पता क्रम में रखी गई; आसन्न मुक्त ब्लॉक प्रत्येक os_free() पर (आगे और पीछे) तुरंत विलय कर दिए जाते हैं
  • उपयोगी होने के लिए पर्याप्त बड़े शेष (≥ BLK_HDR + ALIGN) होने पर आवंटन पर ब्लॉक विभाजित होते हैं
• os_init() आरंभीकरण क्रम — os_mem_init() और os_power_init() को अब os_timer_init() से पहले बुलाया जाता है, ताकि किसी भी टाइमर कॉलबैक या कार्य कोड के चलने से पहले हीप और पावर सबसिस्टम तैयार रहें।
• टिकलेस आइडल लागू किया गया (src/kernel.c: os_kernel_tickless_sleep) — जब os_power_enable_tickless_idle(true) के माध्यम से सक्षम किया जाता है, तो आइडल कार्य WFI से पहले SysTick को दबा देता है और वास्तविक बीता हुआ समय मापने के लिए DWT CYCCNT साइकिल काउंटर का उपयोग करता है। जागने के बाद SysTick पुनरारंभ किया जाता है, मापी गई टिक्स द्वारा उन्नत किया जाता है ( पर कैप किया गया), और किसी भी अतिदेय कार्य को तुरंत अनब्लॉक करने के लिए कॉल किया जाता है। पहले फ़्लैग मौजूद था लेकिन आइडल पथ हमेशा SysTick चलाने के साथ एक सादे पर आ जाता था।

v1.1.0

नई सुविधाएँ

• इवेंट समूहों के लिए EVENT_WAIT_CLEAR फ़्लैग — तब तक प्रतीक्षा करें जब तक बिट्स साफ़ (NOT स्थिति) न हो जाएं। EVENT_WAIT_ALL | EVENT_WAIT_CLEAR जागता है जब सभी मास्क किए गए बिट्स 0 होते हैं; EVENT_WAIT_ANY | EVENT_WAIT_CLEAR जागता है जब कोई भी 0 होता है।
• os_event_group_sync() — रेंडेज़वस / बैरियर प्रिमिटिव। प्रत्येक भाग लेने वाला कार्य अपना स्वयं का आगमन बिट सेट करता है और पूर्ण सेट मौजूद होने तक ब्लॉक करता है; सभी एक साथ अनब्लॉक होते हैं।
• सभी चार मोड (AND, OR, NOT, SYNC) प्रदर्शित करने वाला नया उदाहरण examples/event_flags_logic.c।

बिल्ड और रनटाइम फिक्स

• src/startup.s जोड़ा गया: वेक्टर टेबल, Reset_Handler (.data कॉपी, .bss जीरो), SysTick_Handler स्टब, HardFault_Handler।
• linker.ld जोड़ा गया: mps2-an385 के लिए मेमोरी लेआउट (फ्लैश 0x00000000 / 4 MB, RAM 0x20000000 / 4 MB)।
• प्रारंभिक कार्य स्टैक तय किया गया: R4–R11 सेव एरिया अब पूर्व-आवंटित है ताकि किसी भी नव निर्मित कार्य में पहले कॉन्टेक्स्ट स्विच पर PendSV का LDMIA {R4-R11} सही ढंग से काम करे।
• SVC_Handler PSP सेट करने से पहले LDMIA {R4-R11} में अपडेट किया गया, जिससे SVC और PendSV दोनों पथ सममित रहें।
• os_mpu_configure_default() में MPU_TYPE चेक — जब कोई MPU मौजूद नहीं है (QEMU ) तो MPU सेटअप चुपचाप छोड़ दिया जाता है।

लाइसेंस

MIT लाइसेंस — विवरण के लिए LICENSE देखें।