> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# Rust للأنظمة المدمجة: no_std مع HAL ثم RTIC
- URL: https://arabroot.io/articles/rust-للانظمة-المدمجة-no_std-مع-hal-ثم-rtic/
- Published: 2026-11-06T01:51:31.000Z
- Updated: 2026-11-11T07:53:18.000Z
- Description: نكتب برنامج C الأول بلغة Rust بثلاث طبقات على نفس لوحة STM32 في Renode، ونقارن الحجم بايتاً ببايت، ونرى خمسة أخطاء من C يوقفها المترجم قبل أن تصل إلى الشريحة.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, الإلكترونيات والطائرات المسيرة والطباعة ثلاثية الأبعاد

بعد أن تعلم فريق مسجل الحرارة في الشركة الناشئة كيف يكتب برنامجه بلغة C على الشريحة مباشرة، ثم نقله إلى نظام تشغيل فوري RTOS في [المقال السابق](https://arabroot.io/articles/%D8%A7%D9%86%D8%B8%D9%85%D8%A9-%D8%A7%D9%84%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-%D8%A7%D9%84%D9%81%D9%88%D8%B1%D9%8A%D8%A9-rtos-%D9%85%D8%B9-freertos-%D8%AB%D9%85-zephyr/)، جاء طلب جديد من أحد العملاء الكبار: الجهاز سيدخل في مناقصة لشركة أدوية، وفي شروطها مراجعة أمنية للبرنامج الثابت Firmware، والسؤال الأول في استبيان المراجعة: «ما الذي تفعلونه لمنع أخطاء الذاكرة Memory Safety؟». والفريق يعرف الإجابة الصادقة، فقد رأى في المختبرات السابقة كيف حولت كلمة `volatile` ناقصة حلقة التأخير إلى تعليمة تقفز إلى نفسها للأبد بدون أي تحذير، وكيف طبع برنامج كامل قيمة خاطئة لأن كود البداية نسي خطوة، وكيف انتظرت المهمة الأهم 125 ms لأن أحدهم استخدم إشارة بدل قفل. وكل هذه الأخطاء ترجمت بلغة C بصمت. ولذلك قرر الفريق أن يجرب Rust في الجزء الجديد الذي يحلل رسائل Bluetooth من الهاتف، وهو الجزء الذي يستقبل بيانات من خارج الجهاز، أي الأخطر.

وقد شرحنا لماذا تدفع الحكومات وشركات كبيرة نحو Rust في مقال [أمان الذاكرة Memory Safety](https://arabroot.io/articles/%D8%A7%D9%85%D8%A7%D9%86-%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-memory-safety-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D8%AA%D8%AF%D9%81%D8%B9-%D8%A7%D9%84%D8%AD%D9%83%D9%88%D9%85%D8%A7%D8%AA-%D9%86%D8%AD%D9%88-rust/)، وشرحنا اللغة نفسها وأدواتها في مقال [Rust للمطورين](https://arabroot.io/articles/rust-%D9%84%D9%84%D9%85%D8%B7%D9%88%D8%B1%D9%8A%D9%86-%D8%A7%D9%84%D8%A7%D8%AF%D9%88%D8%A7%D8%AA-cargo-%D9%88%D8%A7%D9%84%D8%A7%D8%B3%D8%A7%D8%B3%D9%8A%D8%A7%D8%AA-%D9%81%D9%8A-%D9%8A%D9%88%D9%85-%D9%88%D8%A7%D8%AD%D8%AF/) والملكية Ownership في مقال [الملكية والاستعارة في Rust](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%84%D9%83%D9%8A%D8%A9-ownership-%D9%88%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%B9%D8%A7%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-result-%D9%81%D9%8A-rust/). والسؤال في هذا المقال مختلف: كيف تبدو Rust على شريحة بلا نظام تشغيل، وكم تكلف من الفلاش مقارنة بـ C، وأي الأخطاء التي رأيناها يمسكها المترجم فعلاً قبل التشغيل وأيها لا يمسكه. وسوف نكتب نفس البرنامج الأول من [مقال C](https://arabroot.io/articles/%D9%84%D8%BA%D8%A9-c-%D9%84%D9%84%D8%A7%D9%86%D8%B8%D9%85%D8%A9-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-embedded-c-%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D9%85%D8%B3%D8%AC%D9%84%D8%A7%D8%AA/) بثلاثة أشكال، ونشغلها على نفس لوحة STM32F4 Discovery في المحاكي Renode، ونقارن الأحجام بايتاً ببايت، ثم نكتب خمسة أخطاء عمداً ونقرأ ما يقوله المترجم عن كل منها.

وسوف نناقش في هذا المقال ما يلي:

- ما معنى `no_std`، وما الذي يبقى من Rust بدون المكتبة القياسية.
- طبقات Rust المدمجة: المعالج `cortex-m-rt`، والمسجلات PAC، والعتاد HAL، وأطر التزامن RTIC وEmbassy.
- كيف تحل Rust مشكلات C التي رأيناها: volatile وكود البداية وملكية العتاد والبيانات المشتركة مع المقاطعات.
- المختبر: نفس البرنامج بثلاثة أشكال في Renode، ومقارنة الحجم مع C، وخمسة أخطاء يمسكها المترجم، ومشكلة حقيقية في RTIC والمحاكي.
- متى تختار Rust لجهازك ومتى تبقى على C، والأخطاء الشائعة، وقائمة تحقق.

## ما معنى no\_std؟ Rust بدون نظام تشغيل

عندما تكتب برنامج Rust عادياً فأنت تستخدم المكتبة القياسية `std`، وفيها الملفات والخيوط والشبكة و`Vec` و`String` و`println!`، وكل هذا يعتمد على نظام تشغيل تحت البرنامج. وعلى الشريحة لا يوجد نظام تشغيل، ولذلك تبدأ كل برامج Rust المدمجة بالسطر `#![no_std]`، الذي يقول للمترجم: لا تربط `std`، واكتف بالمكتبة الأساسية `core`. والمكتبة `core` هي الجزء من Rust الذي لا يحتاج نظام تشغيل ولا ذاكرة ديناميكية: الأنواع والسمات Traits و`Option` و`Result` والمكررات Iterators والشرائح Slices والعمليات الذرية `core::sync::atomic` وتنسيق النصوص `core::fmt`. وما بين الاثنين مكتبة ثالثة اسمها `alloc` فيها `Vec` و`Box`، تستطيع استخدامها إذا وفرت أنت مخصص ذاكرة Allocator، ولكن أغلب الأجهزة الصغيرة لا تفعل ذلك لنفس السبب الذي ذكرناه في C: التجزئة Fragmentation في جهاز يعمل سنوات.

والسطر الثاني في كل برنامج هو `#![no_main]`، لأن الدالة `main` في Rust العادية تستدعيها `std` بعد أن يجهز نظام التشغيل البيئة، وهنا لا يوجد من يفعل ذلك، فنستخدم بدلاً منها السمة `#[entry]` من مكتبة `cortex-m-rt` التي تقوم بكل ما كان يفعله ملف `startup.c` في مقال C. والشيء الثالث الذي يجب أن يوجد في كل برنامج هو معالج الذعر Panic Handler، أي ماذا يفعل البرنامج عندما يحدث خطأ لا يمكن تجاوزه مثل تجاوز حدود مصفوفة، وفي برامجنا هو `panic_halt` الذي يوقف المعالج في حلقة، وفي الأجهزة الحقيقية يكتب الفريق معالجاً يحفظ سبب الخطأ في ذاكرة لا تمسح ثم يعيد تشغيل الجهاز، وهذا موضوع [مقال التصحيح القادم](https://arabroot.io/articles/%D8%AA%D8%B5%D8%AD%D9%8A%D8%AD-%D8%A7%D9%84%D8%A8%D8%B1%D8%A7%D9%85%D8%AC-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-debugging-%D9%85%D8%B9-gdb-%D8%AB%D9%85-renode/).

والهدف Target الذي نترجم له اسمه `thumbv7m-none-eabi`، وهو نفس فكرة `arm-none-eabi` في GCC: تعليمات Thumb بمعمارية Armv7-M، بدون نظام تشغيل، بواجهة EABI، وهو من الأهداف المدعومة رسمياً في [قائمة منصات Rust](https://doc.rust-lang.org/nightly/rustc/platform-support/thumbv7m-none-eabi.html?ref=arabroot.io). ولاحظ أن المعالج في STM32F407 هو Cortex-M4 ويناسبه الهدف `thumbv7em-none-eabihf` الذي يضيف تعليمات DSP ووحدة الأرقام العشرية، ولكننا اخترنا `thumbv7m` لأن Cortex-M4 ينفذ كل تعليمات Cortex-M3، ولأن برنامجنا لا يحتاج الأرقام العشرية، ولكي نستخدم نفس الـ Image من المقالات السابقة التي ثبتنا فيها Rust 1.99.1 مع هذا الهدف فقط.

## طبقات Rust المدمجة: PAC ثم HAL ثم الإطار

في C كتبنا العناوين بأيدينا ثم قلنا إن الفرق في الواقع تستخدم ملفات ST. وفي Rust الطبقات أوضح، وكل طبقة مكتبة Crate منفصلة تنزلها بـ Cargo، ويدير أغلبها [فريق Rust Embedded](https://github.com/rust-embedded/wg?ref=arabroot.io) أو مجتمعات مفتوحة لكل عائلة شرائح:

- **مكتبة المعالج** `cortex-m` و`cortex-m-rt`: الأولى تعطيك طرفيات المعالج مثل SysTick وNVIC وتعليمات مثل `wfi`، والثانية تكتب جدول المقاطعات وكود البداية وملف الربط `link.x`، وأنت تكتب فقط ملفاً صغيراً اسمه `memory.x` فيه منطقتا الفلاش والذاكرة، أي الجزء `MEMORY` من ملف الربط في C. وتفاصيلها في [توثيق cortex-m-rt](https://docs.rs/cortex-m-rt/latest/cortex%5Fm%5Frt/?ref=arabroot.io).
- **طبقة الوصول إلى الطرفيات** Peripheral Access Crate، واختصاراً PAC: مكتبة مولدة آلياً من ملف SVD الذي تنشره الشركة المصنعة ويصف كل مسجل وكل حقل، بأداة اسمها [svd2rust](https://docs.rs/svd2rust/latest/svd2rust/?ref=arabroot.io). فكل مسجل يصبح دالة، وكل حقل دالة، و`dp.GPIOD.moder().modify(|_, w| w.moder12().output())` هو نفس سطر C الذي مسح البتين 25:24 وكتب 01، ولكن بدون أن تكتب أنت رقم البت أو القناع.
- **طبقة تجريد العتاد** HAL: مثل [stm32f4xx-hal](https://github.com/stm32-rs/stm32f4xx-hal?ref=arabroot.io) التي نستخدمها، وتبني فوق PAC واجهة بمفاهيم أعلى: رجل خرج، منفذ تسلسلي بسرعة معينة، ساعة بتردد معين. وكل HAL تطبق سمات مشتركة من مكتبة [embedded-hal](https://github.com/rust-embedded/embedded-hal?ref=arabroot.io) التي وصلت إلى الإصدار 1.0، فيكتب صانع مكتبة حساس الحرارة مشغلاً واحداً يعمل على أي شريحة لها HAL.
- **إطار التزامن**: إما [RTIC](https://rtic.rs/2/book/en/?ref=arabroot.io) الذي يحول المهام إلى مقاطعات بأولويات ويتحقق من الأقفال عند الترجمة، أو [Embassy](https://embassy.dev/?ref=arabroot.io) الذي يعطيك منفذاً async كاملاً مع HAL خاصة به ومكتبات شبكة وBluetooth. وسوف نستخدم RTIC في المختبر لأنه الأقرب لما فعلناه في مقال RTOS.

![أربع طبقات من الأعلى إلى الأسفل: إطار التزامن RTIC 2.4 أو Embassy، ثم طبقة العتاد stm32f4xx-hal 0.23، ثم طبقة المسجلات PAC من stm32f4 0.16 المولدة من SVD، ثم المعالج cortex-m مع cortex-m-rt، وتحتها ما يقابلها في مقال C: startup.c وlink.ld والماكرو REG وملفات ST](https://arabroot.io/content/images/2026/11/embedded-rust-01-layers-1.webp)

طبقات Rust المدمجة بالإصدارات التي استخدمناها في المختبر

## كيف تحل Rust مشكلات C التي رأيناها؟

لنرجع إلى قائمة الأخطاء في مقال C ونرى ماذا يحدث لكل واحد منها في Rust، وهذه أهم نقطة في المقال، لأن الحكم على أي لغة يجب أن يكون على الأخطاء الحقيقية التي يقع فيها فريقك، وليس على قوائم المزايا.

**نسيان volatile**: في C كان الحل أن تتذكر أنت الكلمة عند كل مسجل وكل متغير تشاركه مقاطعة. وفي Rust الوصول إلى المسجلات عبر PAC يمر دائماً بدوال تقرأ وتكتب بطريقة volatile، فلا يوجد مسار تنسى فيه الكلمة. وأما المتغير الذي تشاركه المقاطعة فلا يمكنك أن تكتبه كمتغير عادي أصلاً، لأن المتغير العام القابل للتعديل `static mut` لا يستخدم إلا داخل `unsafe`، وفي إصدار 2024 من اللغة صار أخذ مرجع إليه خطأ افتراضياً كما في [دليل الإصدار](https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html?ref=arabroot.io). والبديل الطبيعي هو `AtomicU32`، أي عدد ذري تقرؤه وتكتبه بعمليات المعالج الذرية، وهذا يحل المشكلة الثانية التي ذكرناها في C، وهي أن `volatile` لا تجعل `ticks++` ذرية.

**كود البداية**: لا تكتبه، لأن `cortex-m-rt` تكتبه وتختبره آلاف المشاريع، فهي تنسخ `.data` وتصفر `.bss` وتضع جدول المقاطعات في مكانه، ولن ترى `boot_magic=0x00000000` لأن أحدهم نسي حلقة النسخ.

**طرفية يستخدمها جزءان من الكود**: في C أي سطر في أي ملف يستطيع أن يكتب في `GPIOD_MODER`، فإذا ضبط زميلك أرجل المنفذ D لناقل SPI ثم ضبطتها أنت للأضواء فإن الأخير يمحو الأول بدون رسالة. وفي Rust كل الطرفيات تأتي من استدعاء واحد `Peripherals::take()` يعطيك قيمتها مرة واحدة فقط، والاستدعاء الثاني يعطي `None`، والقيمة `dp.GPIOD` لها مالك واحد، فإذا نقلتها إلى كود الأضواء لم يعد كود SPI يستطيع أن يأخذها، وهذه هي الملكية Ownership التي تعرفها من Rust العادية، مطبقة على العتاد.

**رجل بالوضع الخطأ**: في C الكتابة في `ODR` لرجل ما زالت دخلاً لا تغير شيئاً على الرجل، ولا تعطي أي خطأ. وفي HAL وضع الرجل جزء من نوعها، فالرجل بعد `split()` نوعها `Pin<'D', 12>`، وبعد `into_push_pull_output()` نوعها `Pin<'D', 12, Output>`، والدالة `set_high` موجودة فقط على النوع الثاني. وهذا النمط يسمى الحالة في النوع Typestate، والجميل فيه أنه لا يكلف أي بايت في البرنامج، لأن الأنواع تختفي بعد الترجمة، وما يبقى هو نفس تعليمة الكتابة في المسجل.

![أربع خطوات من اليمين إلى اليسار: Peripherals::take مرة واحدة، ثم dp.GPIOD.split التي تنقل الملكية وتشغل الساعة، ثم رجل بلا وضع Pin D 12 بدون set_high، ثم into_push_pull_output التي تعطي Pin D 12 Output مع toggle وset_high، وتحتها شرح نمط Typestate وأن الأنواع لا تكلف بايتاً](https://arabroot.io/content/images/2026/11/embedded-rust-04-typestate-1.webp)

من الطرفيات كلها إلى رجل خرج واحدة: كل خطوة تغير النوع، والمترجم يتابعها

والفكرة التي تجمع هذه الخطوات أن العتاد في Rust قيمة تنتقل من يد إلى يد، وليس عنواناً يكتب فيه أي سطر، والمترجم يعرف في كل سطر من يملك كل رجل وفي أي وضع هي. وهذا يغير طريقة المراجعة في الفريق: في C كان المراجع يبحث في كل الملفات عن أي كتابة في `GPIOD_MODER` لكي يتأكد أن أحداً لا يغير الأرجل، وفي Rust يكفيه أن ينظر أين ذهبت القيمة `gpiod.pd12`، لأنه لا يوجد طريق آخر للوصول إليها إلا عبر `unsafe` صريح.

**البيانات المشتركة بين مقاطعة ومهمة**: في RTIC كل مورد مشترك يعلن في بنية `Shared`، والمهمة التي يمكن أن تقطعها مهمة أعلى تستخدم نفس المورد لا تستطيع أن تصل إليه إلا عبر `lock`، والمترجم هو الذي يقرر ذلك من أولويات المهام، فإذا نسيت القفل لا يترجم البرنامج.

وقد يتساءل البعض: هل هذا يعني أن برنامج Rust المدمج لا يحتوي `unsafe`؟ والإجابة لا، ففي أدنى الطبقات توجد كتابات لا يستطيع المترجم أن يتحقق منها، مثل كتابة قيمة خام في مسجل السرعة `BRR`، ولذلك تجد في برنامج PAC السطر `w.bits(0x8B)` داخل `unsafe`، لأن PAC لا تعرف هل القيمة صحيحة للحقل. والفرق أن `unsafe` في Rust مكان محدد ومكتوب يبحث عنه المراجع، أما في C فكل سطر `unsafe` ضمناً. والهدف الواقعي ليس صفراً من `unsafe`، وإنما أن يكون في الطبقات المراجعة جيداً مثل PAC وHAL، وأن يكون كود الجهاز نفسه، أي منطق تحليل الرسائل والحالة والسجل، بدونه.

## المختبر Lab: نفس البرنامج بثلاثة أشكال في Renode

نستخدم نفس Docker Image من المقالات السابقة، وفيها Rust 1.99.1 مع الهدف `thumbv7m-none-eabi`، وأضفنا إليها في هذا المقال طبقة صغيرة فيها مترجم C للجهاز نفسه، لأن ملفات البناء `build.rs` وماكرو الإجراءات Procedural Macros في المكتبات تترجم وتعمل على جهازك أثناء البناء، وليس على الشريحة، وهذا ما ظهر لنا في أول بناء بالخطأ `` linker `cc` not found ``. ونحفظ مكتبات Cargo ومجلد البناء في Docker Volume لكي لا تنزل في كل تشغيل. والمشروع مكتبة واحدة فيها ثلاثة برامج في `src/bin`، وملف المشروع كما يلي:

```toml
[package]
name = "fw-rust"
version = "0.1.0"
edition = "2024"

[dependencies]
cortex-m = { version = "0.7.10", features = ["critical-section-single-core"] }
cortex-m-rt = "0.7.7"
panic-halt = "1.0.0"
stm32f4xx-hal = { version = "0.23.0", features = ["stm32f407"] }
rtic = { version = "2.4.0", features = ["thumbv7-backend"] }
rtic-monotonics = { version = "3.0.0", features = ["cortex-m-systick"] }

[profile.release]
opt-level = "s"       # size first, like -Os in the C version
lto = true            # one optimisation unit for the whole program
codegen-units = 1
debug = true          # symbols for nm/gdb; not written to flash
panic = "abort"

[profile.dev]
panic = "abort"
```

في الملف أعلاه لاحظ التالي:

- الخيار `critical-section-single-core` في `cortex-m` يقول للمكتبات إن الشريحة بنواة واحدة، فيكفي تعطيل المقاطعات لحماية قسم حرج، وعلى شريحة بنواتين يجب اختيار طريقة أخرى.
- الخيار `stm32f407` يختار الشريحة من بين عشرات الشرائح التي تدعمها HAL، فتعرف عناوين طرفياتها وأي الأرجل تصلح لأي وظيفة.
- ملف release بالخيار `opt-level = "s"` يقابل `-Os` في GCC، و`lto = true` مع `codegen-units = 1` يجعل المترجم يرى البرنامج كله مع المكتبات كوحدة واحدة فيحذف ما لا يستخدم، وهذا مهم جداً في Rust لأن كل مكتبة تترجم منفصلة. و`debug = true` يضيف الرموز للمصحح، وهي مثل C لا تكتب في الفلاش.
- `panic = "abort"` يلغي فك المكدس Unwinding عند الذعر، فلا يوجد كود له في البرنامج.

وملف الذاكرة هو كل ما بقي من ملف الربط:

```text
/* STM32F407VG: the same two regions as link.ld in the C version; cortex-m-rt writes the rest of the script */
MEMORY
{
  FLASH : ORIGIN = 0x08000000, LENGTH = 1024K
  RAM   : ORIGIN = 0x20000000, LENGTH = 128K
}
```

وإعداد Cargo يختار الهدف ويضيف ملف الربط من `cortex-m-rt`:

```toml
[build]
target = "thumbv7m-none-eabi"      # Cortex-M3 instruction set, runs unchanged on the Cortex-M4 of the STM32F407

[target.thumbv7m-none-eabi]
rustflags = ["-C", "link-arg=-Tlink.x"]   # link.x comes from cortex-m-rt and includes memory.x
```

### الشكل الأول: PAC، نفس برنامج C سطراً بسطر

البرنامج الأول ترجمة مباشرة لبرنامج C: نفس المسجلات ونفس الترتيب ونفس القيمة `0x8B` ونفس دالة التأخير، والفرق في طريقة الوصول:

```rust
//! The C program from the embedded-c article, line for line, on the register level (PAC).
//! Same board (STM32F407 Discovery in Renode), same registers, same output.
#![no_std]
#![no_main]

use core::sync::atomic::{AtomicU32, Ordering};
use cortex_m::peripheral::syst::SystClkSource;
use cortex_m_rt::{entry, exception};
use panic_halt as _;
use stm32f4xx_hal::pac;

static TICKS: AtomicU32 = AtomicU32::new(0);          // shared with the interrupt: an atomic, not a plain static
static BOOT_MAGIC: AtomicU32 = AtomicU32::new(0xC0FFEE); // initialised: lands in .data like in C
static TOGGLES: AtomicU32 = AtomicU32::new(0);         // zero: lands in .bss

#[exception]
fn SysTick() {
    TICKS.fetch_add(1, Ordering::Relaxed);
}

fn putc(u: &pac::USART2, c: u8) {
    while u.sr().read().txe().bit_is_clear() {}
    u.dr().write(|w| unsafe { w.dr().bits(c as u16) });
}
fn puts(u: &pac::USART2, s: &str) {
    for b in s.bytes() { putc(u, b); }
}
fn put_dec(u: &pac::USART2, mut v: u32) {
    let mut buf = [0u8; 10];
    let mut i = buf.len();
    loop { i -= 1; buf[i] = b'0' + (v % 10) as u8; v /= 10; if v == 0 { break; } }
    for &b in &buf[i..] { putc(u, b); }
}
fn put_hex(u: &pac::USART2, v: u32) {
    puts(u, "0x");
    for i in (0..8).rev() { putc(u, b"0123456789ABCDEF"[((v >> (i * 4)) & 0xF) as usize]); }
}

fn delay_ms(ms: u32) {
    let start = TICKS.load(Ordering::Relaxed);
    while TICKS.load(Ordering::Relaxed).wrapping_sub(start) < ms {}
}

#[entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();          // the only owner of every peripheral
    let mut cp = cortex_m::Peripherals::take().unwrap();

    dp.RCC.ahb1enr().modify(|_, w| w.gpioaen().set_bit().gpioden().set_bit());
    dp.RCC.apb1enr().modify(|_, w| w.usart2en().set_bit());
    dp.GPIOA.moder().modify(|_, w| w.moder2().alternate());
    dp.GPIOA.afrl().modify(|_, w| w.afrl2().af7());
    dp.USART2.brr().write(|w| unsafe { w.bits(0x8B) });  // 16 MHz / 115200
    dp.USART2.cr1().write(|w| w.ue().set_bit().te().set_bit());
    dp.GPIOD.moder().modify(|_, w| w.moder12().output());

    cp.SYST.set_clock_source(SystClkSource::Core);
    cp.SYST.set_reload(16_000 - 1);
    cp.SYST.clear_current();
    cp.SYST.enable_interrupt();
    cp.SYST.enable_counter();

    let u = &dp.USART2;
    puts(u, "embedded-rust lab: STM32F407 PAC\r\n");
    puts(u, "boot_magic="); put_hex(u, BOOT_MAGIC.load(Ordering::Relaxed));
    puts(u, " toggles="); put_dec(u, TOGGLES.load(Ordering::Relaxed)); puts(u, "\r\n");

    loop {
        delay_ms(500);
        dp.GPIOD.odr().modify(|r, w| w.odr12().bit(!r.odr12().bit()));
        let n = TOGGLES.fetch_add(1, Ordering::Relaxed) + 1;
        puts(u, "t="); put_dec(u, TICKS.load(Ordering::Relaxed)); puts(u, "ms led=");
        puts(u, if dp.GPIOD.odr().read().odr12().bit() { "on" } else { "off" });
        puts(u, " toggles="); put_dec(u, n); puts(u, "\r\n");
    }
}
```

في الكود أعلاه لاحظ التالي:

- المتغيرات الثلاثة `AtomicU32` بدل `volatile uint32_t`، والقراءة `load` والزيادة `fetch_add`، والترتيب `Relaxed` يكفي هنا لأننا لا نحمي بيانات أخرى بهذا المتغير، والسؤال عن الترتيب المناسب شرحناه في مقال [التزامن في Rust](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%B2%D8%A7%D9%85%D9%86-concurrency-%D9%81%D9%8A-rust-%D8%A7%D9%84%D8%AE%D9%8A%D9%88%D8%B7-%D8%A7%D9%85-tokio-%D8%A8%D8%A7%D9%84%D9%82%D9%8A%D8%A7%D8%B3/).
- كل سطر في `main` يقابل سطراً في C، و`w.moder2().alternate()` يكتب القيمة 10 في البتين الصحيحين بدون أن نكتب الإزاحة 4 أو القناع 3.
- السطر `dp.GPIOD.odr().modify(|r, w| ...)` هو نفس القراءة والتعديل والكتابة في C، وليس أكثر أماناً منه من ناحية المقاطعات، فالطبقة PAC تعطيك المسجلات كما هي بمشاكلها.
- الحالتان `unsafe` في البرنامج كله كتابة قيم خام: البايت في `DR` والقسمة في `BRR`.
- `SysTick` تحت السمة `#[exception]`، و`cortex-m-rt` تتحقق عند الترجمة أن الاسم استثناء حقيقي في المعالج، فلو كتبت `SysTic` لن يترجم البرنامج، أما في C فكان الاسم الخاطئ سيعني أن الدالة الضعيفة `Default_Handler` تعمل بدلاً منها بدون أي رسالة.

وكل خطوات المختبر في الملف `lab/run.sh`، والتشغيل في Renode بنفس ملف `run.resc` من مقال C مع ضبط ساعة SysTick على 16 MHz، وهو الدرس الذي تعلمناه هناك:

```bash
cd content/articles/embedded-rust/lab
docker run --rm -v fw-src:/src -v "$PWD:/work" fw-toolchain:1 bash /work/run.sh
```

والمخرج:

```text
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[Domain = Elapsed Virtual Time: 00:00:01.200000000
--- uart:
embedded-rust lab: STM32F407 PAC
boot_magic=0x00C0FFEE toggles=0
t=500ms led=on toggles=1
t=1000ms led=off toggles=2
```

نفس المخرج تماماً، والضوء تغير مرتين في 1.2 ثانية، و`boot_magic=0x00C0FFEE`.

### الشكل الثاني: HAL، الأرجل والساعات أنواع

والبرنامج الثاني بنفس السلوك، ولكن بطبقة HAL:

```rust
//! The same blink + UART with the stm32f4xx-hal crate: pins and clocks as types.
#![no_std]
#![no_main]

use core::fmt::Write;
use core::sync::atomic::{AtomicU32, Ordering};
use cortex_m::peripheral::syst::SystClkSource;
use cortex_m_rt::{entry, exception};
use panic_halt as _;
use stm32f4xx_hal::{pac, prelude::*, rcc::Config};

static TICKS: AtomicU32 = AtomicU32::new(0);

#[exception]
fn SysTick() {
    TICKS.fetch_add(1, Ordering::Relaxed);
}

fn delay_ms(ms: u32) {
    let start = TICKS.load(Ordering::Relaxed);
    while TICKS.load(Ordering::Relaxed).wrapping_sub(start) < ms {}
}

#[entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    let mut cp = cortex_m::Peripherals::take().unwrap();

    let mut rcc = dp.RCC.freeze(Config::hsi().sysclk(16.MHz()));   // the clock is a value the compiler tracks
    let gpioa = dp.GPIOA.split(&mut rcc);                          // split() also turns the port clock on
    let gpiod = dp.GPIOD.split(&mut rcc);
    let mut led = gpiod.pd12.into_push_pull_output();              // the type is now Pin<'D', 12, Output>
    let mut tx = dp.USART2.tx(gpioa.pa2, 115_200.bps(), &mut rcc).unwrap(); // PA2 must be a valid TX pin for USART2

    cp.SYST.set_clock_source(SystClkSource::Core);
    cp.SYST.set_reload(rcc.clocks.sysclk().raw() / 1000 - 1);     // derived from the frozen clock, not typed by hand
    cp.SYST.clear_current();
    cp.SYST.enable_interrupt();
    cp.SYST.enable_counter();

    writeln!(tx, "embedded-rust lab: STM32F407 HAL, sysclk={} Hz\r", rcc.clocks.sysclk().raw()).unwrap();
    let mut toggles: u32 = 0;
    loop {
        delay_ms(500);
        led.toggle();
        toggles += 1;
        writeln!(tx, "t={}ms led={} toggles={}\r", TICKS.load(Ordering::Relaxed),
                 if led.is_set_high() { "on" } else { "off" }, toggles).unwrap();
    }
}
```

في الكود أعلاه لاحظ التالي:

- `dp.RCC.freeze(Config::hsi().sysclk(16.MHz()))` يضبط الساعة ويعطيك قيمة `rcc.clocks` فيها الترددات الحقيقية، وكل ما بعده يحسب منها: سرعة المنفذ التسلسلي تحسبها HAL من تردد الناقل، وقيمة SysTick حسبناها من `sysclk` بدل أن نكتب 16000 بأيدينا، وهذا ما نصحنا به في مقال C بعد مشكلة الساعة.
- `dp.GPIOD.split(&mut rcc)` يشغل ساعة المنفذ في RCC بنفسه، فالخطأ الأول في قائمة أخطاء C، نسيان ساعة الطرفية، غير ممكن بهذه الطريقة.
- `dp.USART2.tx(gpioa.pa2, ...)` يأخذ الرجل نفسها ويضبطها على الوظيفة البديلة الصحيحة رقم 7، ولو أعطيته رجلاً لا تصلح لن يترجم البرنامج، وسوف نرى ذلك بعد قليل.
- `writeln!` من `core::fmt` تعطيك تنسيق الأرقام بدل دوال `put_dec` التي كتبناها، ولها ثمن في الحجم سوف نراه.

```text
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[Domain = Elapsed Virtual Time: 00:00:01.200000000
--- uart:
embedded-rust lab: STM32F407 HAL, sysclk=16000000 Hz
t=500ms led=on toggles=1
t=1000ms led=off toggles=2
```

والسطر الأول يطبع `sysclk=16000000 Hz`، أي أن HAL حسبت الساعة كما ضبطناها، ثم نفس التوقيت.

### الشكل الثالث: RTIC 2، مهام بأولويات بدون نواة

والبرنامج الثالث يعيد ما فعلناه في مقال RTOS بطريقة مختلفة تماماً. ففي FreeRTOS كانت هناك نواة فيها مجدول وقوائم مهام، وكل مهمة لها مكدسها، أما RTIC فلا يوجد فيها مجدول يعمل في الخلفية، وإنما تحول كل أولوية إلى مقاطعة برمجية Software Interrupt، أي مقاطعة لطرفية لا نستخدمها مثل `EXTI0` نطلق عليها اسم المرسل Dispatcher، ويصبح المتحكم بالمقاطعات NVIC في المعالج نفسه هو المجدول. والأقفال مبنية على بروتوكول موارد المكدس Stack Resource Policy، فالقفل يرفع سقف الأولوية في المسجل `BASEPRI` إلى أعلى أولوية تستخدم المورد، وهذا يمنع انعكاس الأولوية والجمود معاً، ويحسبه المترجم من الكود، وتجد تفاصيله في [كتاب RTIC](https://rtic.rs/2/book/en/by-example/resources.html?ref=arabroot.io):

```rust
//! RTIC 2: two async tasks with priorities and one shared counter, no RTOS kernel and no heap.
#![no_std]
#![no_main]

use panic_halt as _;

#[rtic::app(device = stm32f4xx_hal::pac, dispatchers = [EXTI0, EXTI1])]
mod app {
    use core::fmt::Write;
    use rtic_monotonics::systick::prelude::*;
    use rtic_monotonics::fugit::ExtU32 as MonoExt;      // both preludes bring a millis(): pick one by name
    use stm32f4xx_hal::{gpio::{Output, PD12}, pac, prelude::*, rcc::Config, serial::Tx};

    systick_monotonic!(Mono, 1000);                    // a 1 kHz time base on SysTick

    #[shared]
    struct Shared { toggles: u32 }                      // touched by both tasks: needs a lock

    #[local]
    struct Local { led: PD12<Output>, tx: Tx<pac::USART2> }

    #[init]
    fn init(cx: init::Context) -> (Shared, Local) {
        let mut rcc = cx.device.RCC.freeze(Config::hsi().sysclk(16.MHz()));
        Mono::start(cx.core.SYST, rcc.clocks.sysclk().raw());
        // Write SYST_CVR once: Renode 1.17 keeps SysTick still until this register is written.
        // Harmless on silicon, where any write just clears the counter.
        unsafe { (*cortex_m::peripheral::SYST::PTR).cvr.write(0) };
        let gpioa = cx.device.GPIOA.split(&mut rcc);
        let gpiod = cx.device.GPIOD.split(&mut rcc);
        let led = gpiod.pd12.into_push_pull_output();
        let mut tx = cx.device.USART2.tx(gpioa.pa2, 115_200.bps(), &mut rcc).unwrap();
        writeln!(tx, "embedded-rust lab: RTIC 2\r").unwrap();
        blink::spawn().ok();
        report::spawn().ok();
        (Shared { toggles: 0 }, Local { led, tx })
    }

    #[idle]
    fn idle(_cx: idle::Context) -> ! {
        loop { cortex_m::asm::wfi(); }                  // sleep until the next interrupt
    }

    #[task(local = [led], shared = [toggles], priority = 1)]
    async fn blink(mut cx: blink::Context) {
        loop {
            Mono::delay(MonoExt::millis(500)).await;             // the task sleeps; nothing spins
            cx.local.led.toggle();
            cx.shared.toggles.lock(|t| *t += 1);         // priority 1 must lock: priority 2 also uses it
        }
    }

    #[task(local = [tx], shared = [toggles], priority = 2)]
    async fn report(mut cx: report::Context) {
        loop {
            Mono::delay(MonoExt::millis(250)).await;
            let n = cx.shared.toggles.lock(|t| *t);
            writeln!(cx.local.tx, "t={}ms toggles={}\r", Mono::now().duration_since_epoch().as_millis(), n).unwrap();
        }
    }
}
```

في الكود أعلاه لاحظ التالي:

- `dispatchers = [EXTI0, EXTI1]`: مقاطعتان لأولويتين، ولو أضفت مهمة بأولوية ثالثة سيطلب منك المترجم مقاطعة ثالثة.
- `toggles` في `Shared` لأن المهمتين تستخدمانه، و`led` و`tx` في `Local` لأن كل واحد منهما لمهمة واحدة، فلا يحتاج قفلاً أبداً.
- المهمتان `async`، و`Mono::delay(...).await` لا يدور في حلقة، وإنما يعيد المعالج للمرسل، ثم إلى المهمة `idle` التي تنفذ `wfi` فينام المعالج حتى المقاطعة التالية.
- المهمة `report` بأولوية 2 تستخدم `lock` أيضاً رغم أنها الأعلى، لأن RTIC تطلب القفل من كل من يستخدم مورداً مشتركاً، والقفل في المهمة الأعلى لا يكلف شيئاً تقريباً لأن المترجم يعرف أنه لا يوجد من يقطعها.
- السطر الذي يكتب في `SYST_CVR` بعد `Mono::start` إصلاح لمشكلة حقيقية واجهتنا، وهي قصة القسم التالي.

وقبل أن يترجم هذا البرنامج أصلاً واجهنا خطأ صغيراً ستقابله غالباً في أول مشروع RTIC مع HAL، فقد كتبنا `Mono::delay(500.millis())` كما في أمثلة RTIC، فرد المترجم:

```text
error[E0034]: multiple applicable items in scope
  --> src/bin/rtic.rs:38:29
   |
38 |             Mono::delay(500.millis()).await;             // the task sleeps; nothing spins
   |                             ^^^^^^ multiple `millis` found
   |
   = note: candidate #1 is defined in an impl of the trait `rtic_monotonics::fugit::ExtU32` for the type `u32`
   = note: candidate #2 is defined in an impl of the trait `stm32f4xx_hal::prelude::_fugit_ExtU32` for the type `u32`
```

والسبب أن السطرين `use rtic_monotonics::systick::prelude::*` و`use stm32f4xx_hal::prelude::*` يأتيان كلاهما بسمة فيها الدالة `millis()` للأعداد، فلا يعرف المترجم أي واحدة تقصد، وهو لا يختار عنك. والحل الذي في البرنامج أن نسمي السمة التي نريدها `use rtic_monotonics::fugit::ExtU32 as MonoExt` ثم نكتب `MonoExt::millis(500)`، وهو نفس ما اقترحه المترجم في رسالته. وهذا مثال على شيء يتكرر في Rust المدمجة: المكتبات من مجتمعات مختلفة تتداخل في الأسماء، والمترجم يرفض الغموض بدل أن يخمن.

### مشكلة حقيقية: مهام RTIC لم تستيقظ في المحاكي

في أول تشغيل لبرنامج RTIC بدون السطرين الأخيرين في `init`، طبع البرنامج `embedded-rust lab: RTIC 2` ثم سكت تماماً، ولم يتغير الضوء، ولا يوجد ذعر ولا خطأ. وأول ما فعلناه أننا طلبنا من Renode أن يسجل أسماء الدوال التي يدخلها المعالج بالأمر `cpu LogFunctionNames true true` لمدة 10 ms، فظهر أن `init` عملت، ثم المهمتان من `EXTI1` و`EXTI0` بدأتا وطلبتا الانتظار، ثم دخل المعالج `SysTick` مرة واحدة فقط، ولم يدخلها بعد ذلك أبداً، أي أن المؤقت الذي يوقظ المهام توقف. ثم جربنا أن نجعل `idle` تدور بتعليمة `nop` بدل `wfi` لنستبعد أن المشكلة في النوم، وبقيت النتيجة نفسها.

والسؤال: لماذا عمل SysTick في برنامج PAC ولم يعمل هنا؟ فقرأنا كود الدالة `_start` في مكتبة `rtic-monotonics`، فوجدنا أنها توقف العداد ثم تضبط قيمة إعادة التحميل ثم تشغله، بدون أن تكتب في مسجل القيمة الحالية `SYST_CVR`، أما برنامج PAC فيستدعي `clear_current()` قبل التشغيل، وكذلك برنامج C بالسطر `SYST_CVR = 0`. فكتبنا برنامجاً صغيراً للتجربة `examples/probe_pendst.rs` يشغل SysTick بنفس طريقة المكتبة، بثلاثة أشكال، ويقرأ Renode العداد بعد 0.1 ثم 0.2 ثانية:

```text
variant: default (like rtic-monotonics start, then PENDSTSET)
0x00000001
0x00000001
variant: --features no-pend
0x00000000
0x00000000
variant: --features clear
0x00000065
0x000000C9
```

والنتيجة واضحة: بدون الكتابة في `SYST_CVR` لا يعد SysTick في Renode 1.17 إطلاقاً، والمقاطعة الواحدة التي رأيناها جاءت من طلب المكتبة اليدوي `PENDSTSET` وليس من العداد، ومع الكتابة جاءت 101 مقاطعة في 0.1 ثانية كما يجب. وعلى الشريحة الحقيقية يعد SysTick بعد تشغيله من قيمته الحالية ثم يحمل قيمة إعادة التحميل عندما يصل إلى الصفر، فالبرنامج كان سيعمل هناك، ولكن قيمة `SYST_CVR` بعد إعادة التشغيل غير معرفة في معمارية Armv7-M، ولذلك يبدأ تسلسل التهيئة الذي توصي به Arm بالكتابة فيه قبل التشغيل، وهذا ما فعلناه في C وفي PAC. أي أن ما رأيناه فرق بين نموذج المحاكي والشريحة، وليس خطأ في RTIC. والإصلاح سطر واحد يكتب صفراً في `SYST_CVR` بعد `Mono::start`، والكتابة في هذا المسجل على الشريحة الحقيقية تصفر العداد فقط، فلا تغير شيئاً في سلوك البرنامج هناك.

![جدول بثلاث طرق لتشغيل SysTick وقيمة العداد بعد 0.1 و0.2 ثانية: بطريقة rtic-monotonics مع PENDSTSET 1 ثم 1، وبدون PENDSTSET 0 ثم 0، ومع كتابة SYST_CVR قبل التشغيل 101 ثم 201، وتحته لماذا عمل برنامج PAC والإصلاح بسطر واحد](https://arabroot.io/content/images/2026/11/embedded-rust-06-systick-1.webp)

التجربة التي كشفت سبب توقف مهام RTIC في Renode

والدرس هنا عن المحاكاة كطريقة عمل: المحاكي نموذج للشريحة، ونماذج الطرفيات فيها فروق صغيرة عن العتاد، مثل ما رأيناه في مقال C حين عمل المنفذ بدون تشغيل ساعته. والطريقة الصحيحة عند الشك أن تصغر المشكلة إلى برنامج تجربة من عشرين سطراً كما فعلنا، ثم تقارن بالوثيقة الرسمية للمعالج، ثم تقرر هل الخطأ في كودك أو المكتبة أو النموذج. وإذا كان في النموذج فإما أن تضيف سطراً لا يضر على العتاد كما فعلنا، أو تبلغ فريق المحاكي، وRenode مفتوح المصدر وتقبل [مستودعه](https://github.com/renode/renode?ref=arabroot.io) البلاغات والتعديلات.

وبعد الإصلاح كان المخرج كما يلي:

```text
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[Domain = Elapsed Virtual Time: 00:00:01.200000000
--- uart:
embedded-rust lab: RTIC 2
t=251ms toggles=0
t=502ms toggles=1
t=753ms toggles=1
t=1004ms toggles=2
```

والضوء تغير مرتين، والمهمة `report` تطبع كل ربع ثانية تقريباً. ولكن انظر إلى الأوقات: 251 ثم 502 ثم 753 ثم 1004، فكل دورة أطول من 250 ms بملي ثانية واحدة، والسبب أن `Mono::delay(250)` يبدأ العد بعد أن تنتهي الطباعة، فيضاف زمنها إلى كل دورة ويتراكم. وهي نفس مشكلة `vTaskDelay` التي ذكرناها في مقال RTOS، والحل هنا `Mono::delay_until` من موعد ثابت يزيد 250 ms في كل دورة. ولاحظ أن `report` طبعت `toggles=1` مرتين متتاليتين، وهذا صحيح لأنها تطبع ضعف ما يقلب الضوء.

![ثلاث بطاقات: report بأولوية 2 على المرسل EXTI1، وblink بأولوية 1 على EXTI0 والقفل يرفع BASEPRI إلى 2، وidle تنفذ wfi، وتحتها مخرج Renode بالأوقات 251 و502 و753 و1004 مع شرح التراكم والحل delay_until](https://arabroot.io/content/images/2026/11/embedded-rust-05-rtic-1.webp)

نموذج RTIC 2 كما يعمل في برنامجنا، والمخرج من Renode

### وماذا عن Embassy؟ الطريقة الثانية للتزامن

اخترنا RTIC في المختبر لأنه الأقرب لنموذج الأولويات الذي شرحناه في مقال RTOS، ولكن الإطار الآخر الذي ستقابله كثيراً هو [Embassy](https://embassy.dev/?ref=arabroot.io)، وفكرته مختلفة. ففي Embassy تكتب كل عمل كدالة `async`، وينفذها منفذ Executor واحد يعمل في حلقة، وعندما تنتظر مهمة شيئاً، مثل وصول بايت على المنفذ التسلسلي أو مرور وقت، تعيد التحكم للمنفذ الذي يشغل مهمة أخرى أو ينيم المعالج، ثم توقظها المقاطعة الخاصة بذلك الحدث. أي أن المهام في المنفذ الواحد تتعاون Cooperative ولا يقطع بعضها بعضاً، وإذا احتجت مهمة تقطع الباقي تنشئ منفذاً ثانياً على مقاطعة بأولوية أعلى. ويأتي Embassy مع HAL خاصة به لكل عائلة شرائح مثل `embassy-stm32` و`embassy-nrf` و`embassy-rp`، كل مشغل فيها مكتوب بطريقة async من البداية، فقراءة المنفذ التسلسلي `uart.read(&mut buf).await` تنام حتى يكتمل النقل بـ DMA بدون أن تكتب أنت أي مقاطعة، ومعه مكتبات للشبكة TCP/IP وBluetooth وUSB.

والفرق العملي بين الاثنين أن RTIC صغير جداً ويعطيك ضمانات توقيت يحسبها المترجم من الأولويات، وهو أقرب لما يعرفه مهندس الأنظمة الفورية، أما Embassy فيعطيك منظومة أكبر جاهزة ويجعل كود الأجهزة المتصلة أسهل بكثير، ولكن المهام داخل المنفذ الواحد يجب ألا تحجز المعالج طويلاً، لأن مهمة واحدة تدور في حلقة بدون `await` توقف كل المهام الأخرى في نفس المنفذ، وهذا أكثر خطأ يقع فيه من يأتي من FreeRTOS. وفي مسجل الحرارة الذي فيه Bluetooth، كان Embassy سيوفر على الفريق كتابة طبقة الاتصال، وكان RTIC سيعطيه سيطرة أكبر على التوقيت، والقرار يعتمد على المكتبات المتوفرة للشريحة التي اختاروها.

### الحجم Size: كم تكلف Rust مقارنة بـ C؟

والآن السؤال الذي يسأله كل مهندس برمجيات مدمجة أولاً:

```text
   text	   data	    bss	    dec	    hex	filename
   1388	      0	     12	   1400	    578	/src/rtarget/thumbv7m-none-eabi/release/pac
   3204	      0	      8	   3212	    c8c	/src/rtarget/thumbv7m-none-eabi/release/hal
   3760	      0	    136	   3896	    f38	/src/rtarget/thumbv7m-none-eabi/release/rtic
```

والبرنامج بلغة C كان 980 بايت من `text` مع `-O2`، و664 مع `-Os`. وبرنامج PAC بلغة Rust 1388 بايت، أي أكبر بـ 408 بايت من نسخة `-O2`، وهذا الفرق ليس في الكود نفسه، ويظهر سببه في الأقسام:

```text
  0 .vector_table 00000188  08000000  08000000  00010000  2**2
  1 .text         0000038c  08000188  08000188  00010188  2**2
  2 .rodata       00000058  08000514  08000514  00010514  2**2
  3 .data         00000000  20000000  20000000  0001056c  2**2
  5 .bss          0000000c  20000000  20000000  00020000  2**2
  6 .uninit       00000000  2000000c  2000000c  00020000  2**2
```

القسم `.vector_table` حجمه `0x188` أي 392 بايت، وفي C كان 64 بايت فقط، لأننا كتبنا هناك 16 خانة للمعالج ولم نضف مقاطعات الشريحة، أما `cortex-m-rt` مع PAC فتكتب جدولاً كاملاً بكل مقاطعات STM32F407، وكلها تشير إلى معالج افتراضي. أي أن 328 بايت من الفرق جاءت من جدول المقاطعات، وأي برنامج C حقيقي يستخدم ملف البداية من ST سيكون فيه نفس الجدول بنفس الحجم. والباقي 80 بايت تقريباً، وأغلبها فحص `unwrap()` بعد `take()` ومعالج الذعر. وكود البرنامج نفسه في `.text` هو `0x38c` أي 908 بايت، مقابل 916 بايت في C، أي أن الطبقة PAC بكل دوالها وأنواعها لم تكلف شيئاً بعد التحسين.

ولاحظ شيئين آخرين في الأقسام والرموز. الأول أن `.data` حجمه صفر، رغم أننا عرفنا `BOOT_MAGIC` بقيمة أولى، والسبب أن البرنامج لا يكتب فيه أبداً، فاستنتج المترجم مع `lto` أنه ثابت فعلياً، فوضع القيمة في الكود مباشرة وحذف المتغير، والدليل أن نسخة debug بدون تحسين فيها `data` بقيمة 4 كما سنرى. والثاني الرموز في الذاكرة:

```text
20000000 00000004 b _RNvCshXpVXF0lpxW_3pac5TICKS
20000000 B __sbss
20000004 00000004 b _RNvCshXpVXF0lpxW_3pac7TOGGLES
20000008 00000001 b _RNvNtCshJMD4rjcfRB_8cortex_m10peripheral5TAKEN.0
20000009 00000001 B DEVICE_PERIPHERALS
2000000c B __ebss
2000000c B __euninit
2000000c B __sheap
2000000c B __suninit
2000000c B _stack_end
```

فالمتغيران `TICKS` و`TOGGLES` بأسمائهما المشفرة بطريقة Rust Name Mangling، وبعدهما بايتان: `TAKEN` من `cortex-m` و`DEVICE_PERIPHERALS` من PAC، وهما العلامتان اللتان تمنعان استدعاء `take()` مرتين، أي أن ضمان المالك الواحد للعتاد يكلف بايتين من الذاكرة. وأما مقاطعة SysTick فأصبحت عملية ذرية:

```text
080001c4 <SysTick>:
 80001c4:	push	{r7, lr}
 80001c6:	mov	r7, sp
 80001c8:	movw	r0, #0
 80001cc:	movt	r0, #8192	@ 0x2000
 80001d0:	ldrex	r1, [r0]
 80001d4:	adds	r1, #1
 80001d6:	strex	r2, r1, [r0]
 80001da:	cmp	r2, #0
 80001dc:	bne.n	80001d0 <SysTick+0xc>
 80001de:	pop	{r7, pc}
```

والتعليمتان `ldrex` و`strex` تقرآن وتكتبان بشكل حصري، فإذا قطعت مقاطعة أخرى العملية بينهما فشلت `strex` وأعادت الحلقة `bne.n` المحاولة، وهذا ما لم يكن في برنامج C الذي كانت فيه `ticks++` قراءة وزيادة وكتابة عادية.

أما HAL بـ 3204 بايت وRTIC بـ 3760 بايت فالزيادة فيهما حقيقية، وأغلبها من التنسيق `writeln!` الذي يأتي بكود `core::fmt` لتحويل الأرقام والنصوص، ومن حساب الساعات في HAL، ومن طابور المؤقت في RTIC. وهذه كلفة تدفعها مرة واحدة، فبرنامج فيه عشرون رسالة منسقة لن يكون أكبر بعشرين ضعفاً، وإذا كان الفلاش ضيقاً جداً تستخدم الفرق مكتبة مثل defmt التي ترسل أرقام الرسائل بدل نصوصها. وآخر رقم في المقارنة نسخة debug من نفس برنامج PAC:

```text
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
   text	   data	    bss	    dec	    hex	filename
  12132	      4	     12	  12148	   2f74	/src/rtarget/thumbv7m-none-eabi/debug/pac
```

أي 12132 بايت، تسعة أضعاف نسخة release، لأن كل دالة صغيرة في PAC وكل طبقة تبقى استدعاء منفصلاً بدون دمج. وهذا الفرق أكبر بكثير منه في C، فلا تحكم على حجم Rust من نسخة debug، ولا تشغل الجهاز في الإنتاج بها، وكثير من الفرق تضبط `opt-level = 1` حتى في ملف dev لكي يبقى التصحيح ممكناً على الشريحة.

![أعمدة للحجم text: C بقيمة 980 بايت، وRust PAC بقيمة 1388، وRust HAL بقيمة 3204، وRust RTIC 2 بقيمة 3760، وتحتها شرح أن 328 بايت من الفرق جدول مقاطعات كامل 392 بايت مقابل 64، وأن HAL وRTIC تدفع كلفة التنسيق مرة واحدة، وأن نسخة debug 12132 بايت](https://arabroot.io/content/images/2026/11/embedded-rust-02-sizes-1.webp)

نفس البرنامج بلغة C وبثلاث طبقات في Rust، والقيمة text بالبايت

### خمسة أخطاء يمسكها المترجم Compiler قبل التشغيل

والآن الجزء الذي يبرر كل ما سبق: كتبنا في مجلد `examples` خمسة برامج صغيرة، كل واحد فيه خطأ من الأخطاء التي رأيناها أو ذكرناها في مقالي C وRTOS، وترجمنا كلاً منها. والأول كود ثان يريد نفس المنفذ:

```rust
    let dp = pac::Peripherals::take().unwrap();
    let mut rcc = dp.RCC.freeze(Config::hsi());
    let leds = dp.GPIOD.split(&mut rcc);      // the LED code owns port D now
    let spi_pins = dp.GPIOD.split(&mut rcc);  // a colleague's SPI code wants port D too
    let _ = (leds, spi_pins);
```

```text
error[E0382]: use of moved value: `dp.GPIOD`
  --> examples/e1_moved.rs:13:20
   |
12 |     let leds = dp.GPIOD.split(&mut rcc);      // the LED code owns port D now
   |                -------- value moved here
13 |     let spi_pins = dp.GPIOD.split(&mut rcc);  // a colleague's SPI code wants port D too
   |                    ^^^^^^^^ value used here after move
   |
   = note: move occurs because `dp.GPIOD` has type `stm32f4::generic::Periph<stm32f4xx_hal::pac::gpioi::RegisterBlock, 1073875968>`, which does not implement the `Copy` trait

For more information about this error, try `rustc --explain E0382`.
error: could not compile `fw-rust` (example "e1_moved") due to 1 previous error
```

والخطأ E0382 هو نفس خطأ الملكية الذي تعرفه من Rust العادية، كما في [شرح الخطأ](https://doc.rust-lang.org/error%5Fcodes/E0382.html?ref=arabroot.io): القيمة `dp.GPIOD` انتقلت إلى `leds` في السطر 12، فلا يمكن استخدامها في السطر 13\. ولاحظ أن نوعها `Periph<..., 1073875968>`، والرقم هو `0x40020C00` بالنظام العشري، أي عنوان المنفذ D نفسه، فالعنوان جزء من النوع. والحل الصحيح في المشروع الحقيقي أن يأخذ كود الأضواء الأرجل التي يحتاجها فقط من نتيجة `split()`، ويعطي الباقي لكود SPI، لأن كل رجل قيمة منفصلة.

والثاني الكتابة على رجل ما زالت دخلاً:

```text
error[E0599]: no method named `set_high` found for struct `stm32f4xx_hal::gpio::Pin<'D', 12>` in the current scope
  --> examples/e2_input.rs:14:9
   |
14 |     led.set_high();
   |         ^^^^^^^^ method not found in `stm32f4xx_hal::gpio::Pin<'D', 12>`
   |
   = note: the method was found for `stm32f4xx_hal::gpio::Pin<P, N, stm32f4xx_hal::gpio::Output<MODE>>`

For more information about this error, try `rustc --explain E0599`.
error: could not compile `fw-rust` (example "e2_input") due to 1 previous error
```

والمترجم لا يقول فقط إن الدالة غير موجودة، وإنما يقول أين وجدها: على `Pin<P, N, Output<MODE>>`، أي أنك تحتاج رجلاً في وضع الخرج.

والثالث طريقة C في مشاركة العداد مع المقاطعة، أي `static mut TICKS`:

```text
error[E0133]: use of mutable static is unsafe and requires unsafe block
  --> examples/e3_static_mut.rs:11:5
   |
11 |     TICKS += 1;                    // written by the interrupt
   |     ^^^^^ use of mutable static
   |
   = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior

error[E0133]: use of mutable static is unsafe and requires unsafe block
  --> examples/e3_static_mut.rs:16:17
   |
16 |     let start = TICKS;             // read by main
   |                 ^^^^^ use of mutable static
   |
   = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior

error[E0133]: use of mutable static is unsafe and requires unsafe block
  --> examples/e3_static_mut.rs:17:11
   |
17 |     while TICKS - start < 500 {}
   |           ^^^^^ use of mutable static
   |
   = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior

For more information about this error, try `rustc --explain E0133`.
error: could not compile `fw-rust` (example "e3_static_mut") due to 3 previous errors
```

ثلاثة أخطاء، واحد لكل استخدام، والملاحظة في آخر كل خطأ تشرح السبب بالضبط: المتغير العام القابل للتعديل يمكن أن يعدله أكثر من طرف، فيحدث سباق أو سلوك غير معرف. وهذا الخطأ هو الذي كان سيمنع مشكلة `volatile` في مقال C كلها، لأنه يجبرك على أن تختار أداة صحيحة، مثل `AtomicU32` كما فعلنا.

والرابع رجل لا تصلح مخرجاً للمنفذ التسلسلي:

```text
error[E0277]: the trait bound `stm32f4xx_hal::gpio::alt::usart2::Tx: From<stm32f4xx_hal::gpio::Pin<'D', 12>>` is not satisfied
    --> examples/e4_wrong_pin.rs:13:28
     |
  13 |     let _tx = dp.USART2.tx(gpiod.pd12, 115_200.bps(), &mut rcc);   // PD12 has no USART2_TX function
     |                         -- ^^^^^^^^^^ the trait `From<stm32f4xx_hal::gpio::Pin<'D', 12>>` is not implemented for `stm32f4xx_hal::gpio::alt::usart2::Tx`
     |                         |
     |                         required by a bound introduced by this call
     |
help: `stm32f4xx_hal::gpio::alt::usart2::Tx<Otype>` implements trait `From<T>`
    --> /src/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stm32f4xx-hal-0.23.0/src/gpio/alt.rs:227:17
     |
 227 | /                 impl<MODE, Otype> From<gpio::$PX<MODE>> for $name<Otype>
 228 | |                 where
 229 | |                     MODE: $crate::gpio::marker::NotAlt + $crate::gpio::PinMode,
 230 | |                     $crate::gpio::Alternate<$A, Otype>: $crate::gpio::PinMode,
     | |                                                                              ^
     | |                                                                              |
     | |______________________________________________________________________________`From<stm32f4xx_hal::gpio::Pin<'A', 2, MODE>>`
     |                                                                                `From<stm32f4xx_hal::gpio::Pin<'D', 5, MODE>>`
...
 238 |                   impl<Otype> From<gpio::$PX<$crate::gpio::Alternate<$A, Otype>>> for $name<Otype> {
     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     |                   |
     |                   `From<stm32f4xx_hal::gpio::Pin<'A', 2, stm32f4xx_hal::gpio::Alternate<7, Otype>>>`
     |                   `From<stm32f4xx_hal::gpio::Pin<'D', 5, stm32f4xx_hal::gpio::Alternate<7, Otype>>>`
     |
    ::: /src/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stm32f4xx-hal-0.23.0/src/gpio/alt/f4.rs:4085:5
     |
4085 | /     pin! {
4086 | |         <Rx> default: PushPull for [
4087 | |             PA3<7>,
...    |
4098 | |         ],
4099 | |     }
     | |_____- in this macro invocation
     = note: required for `stm32f4xx_hal::gpio::Pin<'D', 12>` to implement `Into<stm32f4xx_hal::gpio::alt::usart2::Tx>`
note: required by a bound in `tx`
    --> /src/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stm32f4xx-hal-0.23.0/src/serial.rs:227:22
     |
 225 |     fn tx<WORD>(
```

والرسالة طويلة، ولكن أهم ما فيها في المنتصف: المترجم يعرض الأرجل التي تصلح فعلاً لإرسال USART2، وهي `Pin<'A', 2>` و`Pin<'D', 5>` بالوظيفة البديلة 7، وهذا نفس الجدول الذي كنت ستبحث عنه في ورقة بيانات الشريحة، ولكن مكتوب في أنواع HAL. وفي C هذا الخطأ يترجم ويعمل بلا أي حرف على السلك، وقد تقضي ساعة مع راسم الإشارة قبل أن تكتشف أن الرجل خطأ.

والخامس مهمة بأولوية 1 تعدل العداد المشترك بدون قفل، بينما تستطيع المهمة ذات الأولوية 2 أن تقطعها في المنتصف:

```text
error[E0614]: type `toggles_that_needs_to_be_locked<'_>` cannot be dereferenced
  --> examples/e5_rtic_nolock.rs:22:9
   |
22 |         *cx.shared.toggles += 1;              // priority 2 can interrupt us in the middle of this
   |         ^^^^^^^^^^^^^^^^^^ can't be dereferenced

For more information about this error, try `rustc --explain E0614`.
error: could not compile `fw-rust` (example "e5_rtic_nolock") due to 1 previous error
```

واسم النوع وحده يشرح الخطأ: `toggles_that_needs_to_be_locked`، أي أن RTIC أعطت المهمة نوعاً لا يمكن قراءته إلا عبر القفل. ولو كانت المهمتان بنفس الأولوية لترجم السطر بدون قفل، لأنه لا توجد مهمة تقطع الأخرى، وهذا هو جمال الحساب عند الترجمة: القفل مطلوب فقط حيث يوجد خطر فعلي.

![جدول بخمسة أخطاء: كود ثان يستخدم GPIOD وفي Rust الخطأ E0382، والكتابة على رجل دخل والخطأ E0599، وعداد مشترك مع مقاطعة كمتغير عادي والخطأ E0133، ورجل لا تصلح لـ USART2 والخطأ E0277، ومهمة تعدل بيانات مشتركة بلا قفل والخطأ E0614، مع ما يحدث لكل منها في C، وتحتها ما لا يمسكه المترجم](https://arabroot.io/content/images/2026/11/embedded-rust-03-errors-1.webp)

كل خطأ من هذه يترجم بصمت في C، وفي Rust لا يصل إلى الشريحة

ولكن كن صادقاً مع نفسك في حدود هذه القائمة، فالمترجم لم يمسك مشكلة الساعة في مقال C، ولو كتبنا في HAL `sysclk(48.MHz())` لعمل البرنامج بتوقيت مختلف تماماً عما نريد، ولم يمسك مشكلة SysTick في Renode، ولن يمسك امتلاء المكدس، ولا منطقاً خاطئاً في تحليل رسالة، ولا أي شيء داخل `unsafe`. والقاعدة الصحيحة أن Rust تحذف فئة كاملة من الأخطاء، وهي الفئة الأكثر شيوعاً في الثغرات، وتترك لك باقي الفئات، ولذلك يبقى المحاكي والاختبار ومراجعة الكود كما هي.

## على اللوحة الحقيقية Real Board

الملفات التي شغلناها في Renode هي ملفات ELF عادية، وتكتب في الشريحة الحقيقية بنفس الأدوات التي ذكرناها في مقال C، مثل OpenOCD، أو بأداة [probe-rs](https://probe.rs/?ref=arabroot.io) المكتوبة بـ Rust التي تكتب البرنامج وتفتح المصحح بأمر واحد، ويضبطها كثير من الفرق كأمر تشغيل في Cargo فيصبح `cargo run` هو الكتابة في الشريحة والتشغيل. والموصل الذي تمر عبره كل هذه الأدوات هو واجهة التصحيح SWD التي تراها مكتوبة على يسار اللوحة في الصورة التالية، وموضوعها المقال القادم.

![لوحة STM32F4 Discovery من الأعلى، وعليها الشريحة STM32F407VGT6 في الوسط، والمبرمج ST-LINK في الأعلى مع منفذ USB، ورؤوس الأرجل على الجانبين بأسمائها، وموصل SWD مكتوب على اليسار](https://arabroot.io/content/images/2026/11/embedded-rust-07-discovery-back-1.webp)

لوحة STM32F4 Discovery من الأعلى، والشريحة STM32F407VGT6 في الوسط، والموصل SWD على اليسار. الصورة: Teardown Central، الرخصة [CC BY-SA 2.0](https://creativecommons.org/licenses/by-sa/2.0/?ref=arabroot.io)، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:STM32F4%5FDiscovery%5F%289067300323%29.jpg?ref=arabroot.io) (تم تحويلها إلى WebP).

## متى تختار Rust لجهازك؟ ومتى تبقى على C؟

بعد المختبر الصورة أوضح، والقرار يعتمد على عدة أسئلة عن مشروعك وليس على اللغة وحدها:

| السؤال                                                       | يميل إلى Rust                                                                                                      | يميل إلى C                                        |
| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------- |
| هل يستقبل الجهاز بيانات من الخارج: شبكة أو Bluetooth أو USB؟ | نعم، فهذا مكان أخطاء الذاكرة الخطيرة                                                                               | جهاز مغلق يقرأ حساساً ويشغل محركاً                |
| هل للشريحة HAL ناضجة في Rust؟                                | عائلات STM32 وnRF وRP2040 وESP32 لها دعم واسع                                                                      | شريحة حديثة لا يوجد لها إلا SDK بلغة C من المصنع  |
| ما الذي يعرفه الفريق؟                                        | فريق يعرف Rust أو مستعد لمنحنى تعلم حقيقي                                                                          | فريق خبير في C ومشروع بموعد قريب                  |
| هل هناك متطلبات اعتماد Certification؟                        | توجد أدوات مؤهلة مثل [Ferrocene](https://ferrocene.dev/?ref=arabroot.io) لمعيار ISO 26262 بمستوى ASIL D وIEC 61508 | كل سلسلة أدوات الاعتماد الحالية عندكم مبنية على C |
| هل الكود الموجود كبير؟                                       | جزء جديد ومنفصل يمكن كتابته بـ Rust وربطه بـ C عبر FFI                                                             | إعادة كتابة كل شيء دفعة واحدة قرار نادراً ما ينجح |

والطريق الذي سلكه فريق مسجل الحرارة هو الطريق الواقعي لأغلب الفرق: لا تعيد كتابة الجهاز، وإنما اكتب الجزء الجديد الأخطر بـ Rust، وهو هنا تحليل رسائل Bluetooth، كمكتبة `no_std` لها واجهة C، وتختبرها على جهازك بـ `cargo test` قبل أن تصل إلى الشريحة، لأن منطق التحليل لا يحتاج عتاداً. وقد شرحنا طرق الكتابة الصحيحة في Rust في مقال [الأخطاء الشائعة وأسلوب Rust الصحيح](https://arabroot.io/articles/%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-%D8%B4%D8%A7%D8%A6%D8%B9%D8%A9-%D9%88%D8%A7%D8%B3%D9%84%D9%88%D8%A8-rust-%D8%A7%D9%84%D8%B5%D8%AD%D9%8A%D8%AD-idiomatic-rust/)، وكلها تنطبق هنا.

## كيف يبدو مشروع Rust مدمج في فريق حقيقي؟

الكود الذي كتبناه في المختبر هو الطبقة الدنيا، والمشروع الحقيقي يضيف حوله أدوات وعادات تستحق أن تعرفها قبل أن تبدأ:

- **مكتبتان لا مكتبة واحدة**: منطق الجهاز، مثل تحليل رسائل Bluetooth وحساب متوسطات الحرارة وصيغة السجل، في مكتبة `no_std` لا تعرف شيئاً عن الشريحة، والبرنامج الثابت مكتبة ثانية رقيقة تربط المنطق بالعتاد. والأولى تختبر على جهازك وفي CI بـ `cargo test` العادي بآلاف الحالات، بما فيها رسائل عشوائية بأدوات الاختبار بالمدخلات العشوائية Fuzzing، وهذا أهم ما تكسبه من Rust في الجزء الذي يستقبل بيانات من الخارج.
- **التعامل مع الأخطاء بـ Result**: كل ما قد يفشل بشكل متوقع، مثل رسالة ناقصة أو حساس لا يرد، يعيد `Result` ويعالجه الكود، و`unwrap()` لا يبقى إلا في التهيئة حيث الفشل يعني عتاداً معطوباً. وقد شرحنا هذا الأسلوب في مقال [الملكية والأخطاء Result](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%84%D9%83%D9%8A%D8%A9-ownership-%D9%88%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%B9%D8%A7%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-result-%D9%81%D9%8A-rust/).
- **السجلات بدون نصوص**: بدل `writeln!` الذي رأينا كلفته في الحجم، تستخدم فرق كثيرة مكتبة defmt التي تحفظ النصوص في ملف ELF على جهازك وترسل من الشريحة رقم الرسالة والقيم فقط، فتبقى الرسائل مفصلة والكلفة في الفلاش صغيرة.
- **تحليل الحجم**: أدوات مثل cargo-bloat تعطيك قائمة الدوال مرتبة بالحجم مع المكتبة التي جاءت منها، وهي ما يقابل ملف الخريطة في C عندما تسأل من أين جاءت الكيلوبايتات الإضافية.
- **مراجعة unsafe**: قاعدة في الفريق أن كل `unsafe` له تعليق يبدأ بـ `SAFETY:` يشرح لماذا هو صحيح، وأداة clippy في CI تفشل عند غيابه، فيصبح البحث عن الكود الخطر أمراً واحداً.
- **الربط مع كود C الموجود**: مكتبة Rust تصدر دوالاً بواجهة C عبر `extern "C"` و`#[no_mangle]`، ويربطها مشروع C أو FreeRTOS الموجود كأي مكتبة ثابتة، وهكذا يدخل Rust تدريجياً بدون إعادة كتابة.

## أخطاء شائعة Common Mistakes

- الحكم على حجم Rust من نسخة debug: برنامجنا كان 12132 بايت في debug و1388 في release.
- نسيان `lto = true` و`codegen-units = 1` في ملف release، فيبقى كود المكتبات الذي لا يستخدم.
- مقارنة حجم Rust مع برنامج C بجدول مقاطعات ناقص، ثم الظن أن الفرق كله من اللغة.
- استخدام `static mut` مع `unsafe` لإسكات المترجم بدل `AtomicU32` أو `critical_section::Mutex` أو موارد RTIC.
- `unwrap()` في كل مكان في كود الجهاز، فيتحول كل خطأ متوقع، مثل رسالة Bluetooth ناقصة، إلى ذعر يوقف الجهاز.
- تأخير دوري بـ `delay` بدل `delay_until`، فيتراكم زمن العمل كما رأينا: 251 ثم 502 ثم 753.
- خلط إصدارات `embedded-hal` بين مكتبة HAL ومكتبة مشغل الحساس، فتظهر أخطاء سمات غير مفهومة، والحل التأكد من `cargo tree -d`.
- تجاهل رسائل المترجم الطويلة، وأهم ما فيها غالباً قائمة البدائل الصحيحة، مثل الأرجل التي تصلح لـ USART2.
- الظن أن Rust تمسك أخطاء الساعة والتوقيت والمنطق، وهي لا تمسكها.
- افتراض أن المحاكي يطابق الشريحة في كل شيء، وقد رأينا SysTick لا يعد في Renode حتى يكتب في `SYST_CVR`.

## قائمة تحقق Checklist لمشروع Rust مدمج

- إصدار Rust مثبت في `rust-toolchain.toml` أو في Docker Image، والهدف الصحيح للمعالج.
- ملف `memory.x` يطابق الشريحة الدقيقة، وملف release بـ `opt-level = "s"` و`lto` و`codegen-units = 1`.
- كل العتاد من `Peripherals::take()` مرة واحدة، وكل جزء من الكود يأخذ الأرجل والطرفيات التي يحتاجها فقط.
- لا يوجد `static mut` في كود الجهاز، والبيانات المشتركة بأنواع ذرية أو موارد RTIC أو `critical_section::Mutex`.
- كل `unsafe` له تعليق يشرح لماذا هو آمن، ومحصور في طبقة صغيرة تراجع بعناية.
- معالج ذعر يحفظ السبب ويعيد التشغيل في الإنتاج، بدل الحلقة التي لا تنتهي.
- منطق الجهاز الذي لا يحتاج عتاداً في مكتبة منفصلة تختبر بـ `cargo test` على جهازك وفي CI.
- خطوة في CI تطبع الحجم وتفشل عند تجاوز الحد، وتشغيل في محاكي بنفس الساعة.

## تدريب عملي Practice

- غير `report` في برنامج RTIC إلى `Mono::delay_until` من موعد يزيد 250 ms في كل دورة، وتأكد أن الأوقات صارت 250 و500 و750 و1000.
- أضف إلى برنامج HAL الأضواء على PD13 وPD14 وPD15 بالتتابع، وحاول أن تعطي نفس الرجل لمهمتين، واقرأ رسالة المترجم.
- غير الهدف في `.cargo/config.toml` إلى `thumbv7em-none-eabi` بعد تثبيته بـ `rustup target add`، وقارن الحجم مع النسخة الحالية.
- اجعل المهمتين في RTIC بنفس الأولوية، واحذف القفل من إحداهما، ولاحظ أن البرنامج يترجم الآن، وفسر لماذا.

## الخلاصة Summary

وصلنا لنهاية الموضوع، وأهم ما فيه:

- `no_std` يعني Rust بالمكتبة `core` فقط، و`cortex-m-rt` تكتب جدول المقاطعات وكود البداية وملف الربط، وأنت تكتب `memory.x`.
- الطبقات واضحة: PAC مولدة من SVD وكل وصول فيها volatile، ثم HAL بأرجل وساعات لها أنواع، ثم RTIC أو Embassy للمهام.
- نفس البرنامج كان 980 بايت بلغة C و1388 بايت في Rust PAC، و328 بايت من الفرق جدول مقاطعات كامل، وكود البرنامج نفسه 908 بايت مقابل 916.
- HAL بـ 3204 بايت وRTIC بـ 3760 بايت تدفع كلفة التنسيق والساعات والمؤقت مرة واحدة، ونسخة debug 12132 بايت فلا تقس الحجم بها.
- خمسة أخطاء تترجم بصمت في C أوقفها المترجم: E0382 لطرفية بمالكين، وE0599 لرجل دخل، وE0133 لعداد مشترك، وE0277 لرجل لا تصلح، وE0614 لبيانات مشتركة بلا قفل.
- مهام RTIC لم تستيقظ في Renode 1.17 لأن نموذج SysTick لا يعد حتى يكتب في `SYST_CVR`، والإصلاح سطر واحد لا يضر على الشريحة.
- Rust تحذف فئة أخطاء الذاكرة والسباق، ولا تحذف أخطاء الساعة والمنطق والعتاد، فيبقى المحاكي والاختبار.

وفي [المقال القادم](https://arabroot.io/articles/%D8%AA%D8%B5%D8%AD%D9%8A%D8%AD-%D8%A7%D9%84%D8%A8%D8%B1%D8%A7%D9%85%D8%AC-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-debugging-%D9%85%D8%B9-gdb-%D8%AB%D9%85-renode/) من مرحلة [البرمجيات المدمجة Firmware](https://arabroot.io/start/#stage-elec-firmware) بإذن الله سوف نصل المصحح GDB بالمحاكي، ونتسبب في عطل HardFault حقيقي ونشخصه من مسجلات المعالج. وإلى ذلك الحين، هذه مقالات Rust التي يبني عليها هذا المقال:

[![](https://arabroot.io/content/images/2026/11/embedded-debugging-cover-cover-1.webp)دليلتصحيح البرامج المدمجة Debugging مع GDB ثم Renodeنزرع في برنامج مسجل حرارة ثلاثة أخطاء حقيقية ونشخصها بـ GDB على QEMU ثم Renode، بنقاط المراقبة وإطار الاستثناء ومسجلات العطل، ثم نكتب اختبارات Renode تمنع عودتها.](https://arabroot.io/articles/%D8%AA%D8%B5%D8%AD%D9%8A%D8%AD-%D8%A7%D9%84%D8%A8%D8%B1%D8%A7%D9%85%D8%AC-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-debugging-%D9%85%D8%B9-gdb-%D8%AB%D9%85-renode/)[![](https://arabroot.io/content/images/2026/10/rust-for-devs-cover-cover.webp)دليلRust للمطورين: الأدوات Cargo والأساسيات في يوم واحدثبتنا Rust 1.99.1 من الصفر وبنينا مكتبة تحسب قيمة الطلب والضريبة بالهللات، ومررنا عليها بكل أداة ستكتبها يومياً مع المخرج الحقيقي، وما يفاجئ القادم من Python وJava وGo.](https://arabroot.io/articles/rust-%D9%84%D9%84%D9%85%D8%B7%D9%88%D8%B1%D9%8A%D9%86-%D8%A7%D9%84%D8%A7%D8%AF%D9%88%D8%A7%D8%AA-cargo-%D9%88%D8%A7%D9%84%D8%A7%D8%B3%D8%A7%D8%B3%D9%8A%D8%A7%D8%AA-%D9%81%D9%8A-%D9%8A%D9%88%D9%85-%D9%88%D8%A7%D8%AD%D8%AF/)[![](https://arabroot.io/content/images/2026/10/rust-types-memory-cover-cover.webp)دليلالأنواع والملكية Ownership والأخطاء Result في Rustقسنا أحجام الأنواع وعدد الحجوزات والذاكرة عند النقل والاستنساخ، وقرأنا ست رسائل حقيقية من مدقق الاستعارة، ثم رأينا كيف تفشل Rust بالأخطاء والتوقف ورموز الخروج.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%84%D9%83%D9%8A%D8%A9-ownership-%D9%88%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%B9%D8%A7%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-result-%D9%81%D9%8A-rust/)[![](https://arabroot.io/content/images/2026/10/memory-safety-rust-cover-cover.webp)دليلأمان الذاكرة Memory Safety: لماذا تدفع الحكومات نحو Rust؟ماذا طلبت الحكومات فعلاً بشأن C وC++، ولماذا تسبب أخطاء الذاكرة أغلب الثغرات الخطيرة، ومتى يكون Rust هو الاختيار الصحيح.](https://arabroot.io/articles/%D8%A7%D9%85%D8%A7%D9%86-%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-memory-safety-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D8%AA%D8%AF%D9%81%D8%B9-%D8%A7%D9%84%D8%AD%D9%83%D9%88%D9%85%D8%A7%D8%AA-%D9%86%D8%AD%D9%88-rust/)[![](https://arabroot.io/content/images/2026/10/rust-concurrency-cover-cover.webp)دليلالتزامن Concurrency في Rust: الخيوط أم Tokio بالقياسقسنا مئة استدعاء بطيء وهاشاً ثقيلاً بالخيوط وTokio وRayon، ثم رأينا ما يرفضه المترجم من أخطاء التزامن وما يمر منه: مخزون بيع مرتين وجمود يظهر مرة من ثلاث.](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%B2%D8%A7%D9%85%D9%86-concurrency-%D9%81%D9%8A-rust-%D8%A7%D9%84%D8%AE%D9%8A%D9%88%D8%B7-%D8%A7%D9%85-tokio-%D8%A8%D8%A7%D9%84%D9%82%D9%8A%D8%A7%D8%B3/)[![](https://arabroot.io/content/images/2026/10/rust-idioms-cover-cover.webp)دليلأخطاء شائعة وأسلوب Rust الصحيح Idiomatic Rustأربعة عشر خطأ يقع فيها القادمون إلى Rust من لغات أخرى، من قص النص العربي بالفهرس إلى النوم داخل async، لكل منها تشغيل حقيقي وإصلاح، ثم خطة قراءة من المصادر الرسمية.](https://arabroot.io/articles/%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-%D8%B4%D8%A7%D8%A6%D8%B9%D8%A9-%D9%88%D8%A7%D8%B3%D9%84%D9%88%D8%A8-rust-%D8%A7%D9%84%D8%B5%D8%AD%D9%8A%D8%AD-idiomatic-rust/)

## سجل التحديثات Changelog

- نوفمبر 2026: كتابة المقال، وبناء البرامج داخل Container من Docker Image fw-toolchain:1 مع Rust 1.99.1 والهدف thumbv7m-none-eabi، والمكتبات cortex-m 0.7.10 وcortex-m-rt 0.7.7 وstm32f4 0.16.0 وstm32f4xx-hal 0.23.0 وrtic 2.4.0 وrtic-monotonics 3.0.0، والتشغيل في Renode 1.17.0 بوصف اللوحة stm32f4\_discovery-kit، على Docker Engine 29.8.0.