> ## 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.

# لغة C للأنظمة المدمجة Embedded C: الذاكرة والمسجلات
- URL: https://arabroot.io/articles/لغة-c-للانظمة-المدمجة-embedded-c-الذاكرة-والمسجلات/
- Published: 2026-11-06T01:49:31.000Z
- Updated: 2026-11-11T07:53:15.000Z
- Description: نكتب برنامجاً كاملاً لشريحة STM32F407 بدون أي مكتبة، من خريطة الذاكرة والمسجلات إلى كود البداية وملف الربط، ثم نشغله في Renode، ثم نقرأ ملف الخريطة ومخرج size.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, الإلكترونيات والطائرات المسيرة والطباعة ثلاثية الأبعاد

لنفرض أنك مطور تكتب خدمات الويب بلغة Go أو Python في شركة ناشئة تصنع جهازاً صغيراً يوضع داخل صناديق شحن الأدوية واللقاحات المبردة، ويسجل درجة الحرارة كل دقيقة طوال الطريق، ثم يرسل السجل عند الوصول لكي يعرف المستلم هل بقيت الشحنة في المدى المسموح أم لا، وهو ما يسمى في الصناعة مسجل البيانات لسلسلة التبريد Cold Chain Data Logger. وكان عملك حتى الآن في السيرفر الذي يستقبل هذه السجلات، ثم ترك مهندس البرمجيات المدمجة الوحيد في الفريق العمل، وأصبح مطلوباً منك أن تفهم الكود الذي يعمل داخل الجهاز نفسه وتعدل عليه. فتفتح المستودع وتجد ملفاً اسمه `startup.c` فيه مصفوفة من العناوين لا يستدعيها أحد، وملفاً بامتداد `.ld` مكتوباً بلغة لم ترها من قبل، وسطوراً مثل `*(volatile uint32_t *)0x40020C14 ^= 1u << 12;`، ولا يوجد نظام تشغيل ولا `printf` ولا `main` يستدعيه أحد بالطريقة التي تعرفها.

واللغة هنا هي C التي قد تكون تعلمتها، وقد شرحنا أدواتها في مقال [لغة C لمن يبرمج بلغة أخرى](https://arabroot.io/articles/%D9%84%D8%BA%D8%A9-c-%D9%84%D9%85%D9%86-%D9%8A%D8%A8%D8%B1%D9%85%D8%AC-%D8%A8%D9%84%D8%BA%D8%A9-%D8%A7%D8%AE%D8%B1%D9%89-%D8%A7%D9%84%D9%85%D8%AA%D8%B1%D8%AC%D9%85-gcc-%D9%88%D8%A7%D9%84%D8%A7%D8%AF%D9%88%D8%A7%D8%AA/) والمؤشرات والذاكرة في مقال [المؤشرات Pointers والذاكرة في C](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D8%A4%D8%B4%D8%B1%D8%A7%D8%AA-pointers-%D9%88%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-%D9%81%D9%8A-%D9%84%D8%BA%D8%A9-c/)، ولكن الذي تغير هو البيئة: فالبرنامج يعمل على متحكم دقيق Microcontroller بلا نظام تشغيل، ويكلم العتاد مباشرة عبر عناوين في الذاكرة، ويبدأ من كود تكتبه أنت قبل `main`. وهذا المقال هو الأول في مرحلة [البرمجيات المدمجة Firmware](https://arabroot.io/start/#stage-elec-firmware)، وسوف نكتب فيه برنامجاً كاملاً من الصفر لشريحة STM32F407 من شركة ST، يضيء الضوء الأخضر على اللوحة ويطبع على المنفذ التسلسلي، بدون أي مكتبة جاهزة، ثم نشغله في المحاكي Renode كما تفعل الفرق التي تختبر البرامج المدمجة في خط التكامل المستمر CI قبل أن تصل إلى اللوحة، ونقرأ كل مخرج سطراً بسطر.

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

- ما الذي يختلف في البرامج المدمجة Embedded عن البرامج التي تعمل فوق نظام تشغيل، ولماذا بقيت C لغتها الأولى.
- سلسلة الأدوات Toolchain للترجمة المتقاطعة Cross Compilation: المترجم arm-none-eabi-gcc ومكتبة C الصغيرة.
- خريطة الذاكرة Memory Map، والمسجلات Registers، وكيف تقرأ دليل المرجع Reference Manual لتعرف أي بت تكتب.
- الكلمة `volatile`: لماذا يحتاجها كل كود مدمج، وما الذي لا تفعله.
- كود البداية Startup Code وجدول المقاطعات Vector Table، وملف الربط Linker Script وعنوانا التحميل والتشغيل.
- المختبر: البناء في Docker والتشغيل في Renode، ثم ملف الخريطة Map File ومخرج `size`، ومشكلة حقيقية في الساعة، وثلاث تجارب «ماذا يحدث إذا».
- الطريق من المحاكي إلى اللوحة الحقيقية، والأخطاء الشائعة، وقائمة تحقق.

## ما الذي يختلف في البرامج المدمجة Embedded Software؟

عندما تكتب خدمة ويب فأنت تقف فوق طبقات كثيرة لا تراها: نظام تشغيل يحمل برنامجك في الذاكرة، ويعطيه ذاكرة افتراضية Virtual Memory خاصة به، ويجهز له المكدس Stack والكومة Heap، ويستدعي `main`، ويعطيه الملفات والشبكة عبر استدعاءات النظام System Calls، وقد شرحنا هذه الطبقة في مقال [فضاء النواة وفضاء المستخدم](https://arabroot.io/articles/%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9-%D9%88%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D8%B3%D8%AA%D8%AF%D8%B9%D8%A7%D8%A1%D8%A7%D8%AA-%D8%A7%D9%84%D9%86%D8%B8%D8%A7%D9%85/). أما البرنامج المدمج، ويسمى غالباً البرنامج الثابت Firmware لأنه يحفظ في ذاكرة الجهاز ولا يتغير إلا بتحديث، فيعمل في الغالب مباشرة على العتاد بدون أي طبقة تحته، وهذا ما يسمى العمل المباشر على العتاد Bare Metal. فلا يوجد من يحمل البرنامج، لأنه مكتوب أصلاً في ذاكرة الفلاش Flash داخل الشريحة، ولا يوجد من يجهز الذاكرة، ولا يوجد شيء اسمه ملف أو عملية Process، والطريقة الوحيدة للتعامل مع العالم الخارجي هي الكتابة والقراءة في عناوين محددة تتصل بالأجهزة الطرفية Peripherals مثل المنفذ التسلسلي والمؤقتات والأرجل التي تخرج منها الإشارات.

والمتحكم الدقيق Microcontroller، واختصاراً MCU، هو حاسب كامل في شريحة واحدة: معالج وذاكرة فلاش للبرنامج وذاكرة عشوائية SRAM للمتغيرات وطرفيات، وكلها داخل قطعة أصغر من ظفر الإصبع وتستهلك ميلي أمبيرات قليلة. والشريحة التي سنعمل عليها STM32F407 فيها معالج [Arm Cortex-M4](https://www.arm.com/products/silicon-ip-cpu/cortex-m/cortex-m4?ref=arabroot.io) وفلاش بحجم 1 MB وذاكرة SRAM بحجم 192 KB، منها 128 KB في المنطقة الرئيسية التي سنستخدمها، وهذه الأرقام صغيرة جداً مقارنة بسيرفر فيه عشرات الجيجابايت، وهذا الفرق هو سبب أغلب ما ستراه في هذا المقال. فأنت تحسب البايتات، وتعرف عنوان كل متغير، وتقرر بنفسك أين يوضع المكدس وكم حجمه.

وقد يتساءل البعض: لماذا ما زالت C هي اللغة الأولى هنا وقد ظهرت لغات أحدث وأكثر أماناً؟ والإجابة أن C تعطيك ثلاثة أشياء يحتاجها هذا العالم بالضبط: الوصول المباشر إلى العناوين عبر المؤشرات، وبرنامج ناتج صغير يمكنك أن تعرف حجمه وتوقيته بدقة، وعدم وجود أي شيء يعمل في الخلفية بدون علمك مثل جامع القمامة Garbage Collector. ولأن كل شركة تصنع شرائح تعطيك ملفات الترويسة والأمثلة بلغة C، وكذلك المعيار [CMSIS](https://arm-software.github.io/CMSIS%5F6/latest/Core/index.html?ref=arabroot.io) من Arm الذي يوحد طريقة الوصول إلى معالجات Cortex-M، فأي فريق يبدأ مشروعاً مدمجاً سيجد كل ما حوله مكتوباً بها. وسوف نرى في [مقال قادم من هذه المرحلة](https://arabroot.io/articles/rust-%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-no%5Fstd-%D9%85%D8%B9-hal-%D8%AB%D9%85-rtic/) كيف تغير 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/)، ولكن فهم ما يحدث في C هو الأساس الذي تقوم عليه كل الطرق الأخرى، لأن Rust نفسها تولد نفس جدول المقاطعات ونفس الأقسام التي سنشرحها.

ولاحظ أيضاً أن الخطأ في البرنامج المدمج له ثمن مختلف، فالسيرفر الذي يتعطل يعاد تشغيله في ثوان، أما الجهاز الذي يتجمد داخل صندوق شحن فلن يراه أحد حتى يصل، وعندها تكون الشحنة قد فسدت أو لم تسجل. وقد رأينا في مقال [جهاز Therac-25](https://arabroot.io/articles/%D8%AC%D9%87%D8%A7%D8%B2-therac-25-%D9%88%D8%A3%D8%AE%D8%B7%D8%A7%D8%A1-%D8%A7%D9%84%D8%A8%D8%B1%D9%85%D8%AC%D9%8A%D8%A7%D8%AA-%D8%A7%D9%84%D8%AD%D8%B1%D8%AC%D8%A9/) كيف يمكن لخطأ توقيت في برنامج مدمج أن يؤذي الناس مباشرة، ولذلك ستجد أن الفرق في هذا المجال أكثر تحفظاً في استخدام اللغة، وتلتزم غالباً بقواعد مكتوبة مثل [MISRA C](https://misra.org.uk/?ref=arabroot.io) التي تمنع أجزاء من C معروفة بأنها مصدر للأخطاء.

## سلسلة الأدوات Toolchain: الترجمة لمعالج آخر

المعالج في جهازك Intel أو AMD من نوع x86-64، والمعالج في المتحكم من نوع Arm بتعليمات Thumb، فلا يمكنك أن تترجم بالمترجم العادي وتشغل الناتج، وإنما تحتاج مترجماً يعمل على جهازك ويولد كوداً لمعالج آخر، وهذا ما يسمى الترجمة المتقاطعة Cross Compilation. والمترجم الذي يستخدمه أغلب الفرق اسمه `arm-none-eabi-gcc`، والاسم نفسه يشرح ما يفعله: `arm` هو المعالج الهدف، و`none` تعني أنه لا يوجد نظام تشغيل على الهدف، و`eabi` هي واجهة الاستدعاء الثنائية Embedded Application Binary Interface التي تحدد كيف تمرر المعاملات بين الدوال وأي مسجلات تحفظ. ويأتي معه الرابط Linker والمجمع Assembler وأدوات مثل `objdump` و`nm` و`size` بنفس البادئة، وتنشره Arm نفسها على صفحة [Arm GNU Toolchain](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads?ref=arabroot.io)، وتوفره التوزيعات كحزمة، ففي Debian 13 الحزمة [gcc-arm-none-eabi](https://packages.debian.org/trixie/gcc-arm-none-eabi?ref=arabroot.io) وفيها GCC 14.2.

والجزء الثاني الذي يجب أن تعرفه هو مكتبة C القياسية، فعلى Linux تأتي مكتبة glibc الضخمة التي تعتمد على النواة في كل شيء، وهذه لا تصلح لشريحة فيها 128 KB من الذاكرة. لذلك يوجد في هذا العالم مكتبات صغيرة مصممة للأنظمة المدمجة، أشهرها [newlib](https://sourceware.org/newlib/?ref=arabroot.io) و[picolibc](https://github.com/picolibc/picolibc?ref=arabroot.io)، وهي تعطيك `memcpy` و`strlen` و`printf`، ولكنها تطلب منك أن تكتب بنفسك الدوال التي تتصل بالعتاد، مثل الدالة التي تخرج حرفاً على المنفذ التسلسلي. وفي مختبرنا سوف نذهب خطوة أبعد ولا نستخدم أي مكتبة، بالخيارين `-nostdlib -nostartfiles`، لكي ترى كل بايت في البرنامج وتعرف من أين جاء، وهذا أفضل طريق للتعلم، ثم تضيف المكتبة في المشاريع الحقيقية وأنت تعرف ما الذي تضيفه.

ولكي لا تثبت أي شيء على جهازك، وضعنا كل الأدوات في Docker Image واحدة مبنية على Debian 13، فيها المترجم وأدوات binutils والمصحح `gdb-multiarch` والمحاكي QEMU والمحاكي Renode بإصدار 1.17.0، وسوف نستخدم نفس الـ Image في كل مقالات هذه المرحلة. وملف البناء كما يلي:

```dockerfile
# Toolchain for the firmware stage (embedded-c, rtos-freertos-zephyr, embedded-rust, embedded-debugging, low-power-design):
#   docker build -t fw-toolchain:1 content/articles/embedded-c/lab
FROM debian:trixie-20261104-slim
ARG RENODE=1.17.0
ARG RUST=1.99.1
RUN apt-get update && apt-get install -y --no-install-recommends \
      gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi picolibc-arm-none-eabi \
      gdb-multiarch qemu-system-arm make cmake ninja-build device-tree-compiler \
      python3 python3-venv python3-pip git ca-certificates curl xz-utils file bc \
    && rm -rf /var/lib/apt/lists/*
# Renode: the official portable Linux build (bundled .NET runtime)
RUN curl -fsSL https://github.com/renode/renode/releases/download/v${RENODE}/renode-${RENODE}.linux-portable.tar.gz \
      | tar -xz -C /opt && mv /opt/renode_${RENODE}* /opt/renode && ln -s /opt/renode/renode /usr/local/bin/renode \
    && ln -s /opt/renode/renode-test /usr/local/bin/renode-test
# Rust: pinned stable with the Cortex-M3 target
ENV RUSTUP_HOME=/opt/rustup CARGO_HOME=/opt/cargo PATH=/opt/cargo/bin:/opt/venv/bin:$PATH
RUN curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain ${RUST} --target thumbv7m-none-eabi \
    && chmod -R a+rwX /opt/rustup /opt/cargo
# Python: west for Zephyr, Robot Framework for renode-test
RUN python3 -m venv /opt/venv && /opt/venv/bin/pip install --no-cache-dir west==1.5.0 pyelftools jsonschema pykwalify pyyaml packaging anytree intelhex
# Host C compiler: Rust build scripts (build.rs) and proc macros are compiled for the PC, not for the chip
RUN apt-get update && apt-get install -y --no-install-recommends gcc libc6-dev && rm -rf /var/lib/apt/lists/*
WORKDIR /work
```

وبناؤها بأمر واحد من مجلد المختبر:

```bash
docker build -t fw-toolchain:1 content/articles/embedded-c/lab
docker run --rm fw-toolchain:1 arm-none-eabi-gcc --version | head -1
```

والمخرج سوف يكون كما يلي:

```text
arm-none-eabi-gcc (15:14.2.rel1-1) 14.2.1 20241119
```

والرقم `14.2.rel1` هو رقم إصدار Arm للأدوات، وهو نفسه الذي تنزله من صفحتها، وDebian أعادت تغليفه فقط.

## خريطة الذاكرة Memory Map: كل شيء له عنوان

أول فكرة يجب أن تتغير في رأسك أن «الذاكرة» في المتحكم ليست مكاناً للمتغيرات فقط، وإنما مساحة عناوين واحدة بحجم 4 GB، لأن المعالج 32 بت، وكل شيء في الشريحة له مكان فيها. فالفلاش الذي فيه البرنامج يبدأ من العنوان `0x08000000`، والذاكرة SRAM تبدأ من `0x20000000`، والطرفيات تبدأ من `0x40000000`، وطرفيات المعالج نفسه مثل المؤقت SysTick والمتحكم بالمقاطعات NVIC تبدأ من `0xE000E000`. والعناوين بينها فارغة، أي لا يوجد خلفها أي شيء، والقراءة منها تسبب خطأ في الناقل Bus Fault. وهذه الخريطة تجدها في ورقة البيانات Datasheet وفي دليل المرجع Reference Manual للشريحة، وهو للشريحة STM32F407 الوثيقة RM0090 من ST، وتجدها أيضاً مكتوبة بلغة C في ملف الترويسة الرسمي [stm32f407xx.h](https://github.com/STMicroelectronics/cmsis-device-f4/blob/master/Include/stm32f407xx.h?ref=arabroot.io) الذي تنشره ST على GitHub، وفيه مثلاً `FLASH_BASE 0x08000000UL` و`PERIPH_BASE 0x40000000UL`.

![جدول بخريطة ذاكرة STM32F407 من الأعلى إلى الأسفل: طرفيات المعالج عند 0xE000E000 وفيها SysTick وNVIC، ثم RCC عند 0x40023800، وGPIOD عند 0x40020C00 وفيه الضوء على PD12، وGPIOA عند 0x40020000، وUSART2 عند 0x40004400، والذاكرة SRAM عند 0x20000000 وفيها متغيرات البرنامج والمكدس، والفلاش عند 0x08000000 وفيه جدول المقاطعات والكود](https://arabroot.io/content/images/2026/11/embedded-c-01-memory-map-1.webp)

خريطة الذاكرة للأجزاء التي يستخدمها برنامجنا، بالعناوين الحقيقية من ملف ST ومن مخرج nm

والطرفيات مقسمة على نواقل Buses، وكل ناقل له سرعته، فالمنافذ GPIO مثلاً على الناقل AHB1 الذي يبدأ من `0x40020000`، والمنفذ التسلسلي USART2 على الناقل الأبطأ APB1 الذي يبدأ من `0x40000000`. ولكل طرفية مجموعة من المسجلات Registers، وكل مسجل خانة بحجم 32 بت في عنوان ثابت، فالمنفذ GPIOD يبدأ من `0x40020C00`، ومسجل الخرج فيه `ODR` على الإزاحة `0x14`، أي في العنوان `0x40020C14`. والفرق المهم بين المسجل والمتغير أن الكتابة في المسجل لها أثر في العالم الحقيقي: فعندما تكتب 1 في البت 12 من `ODR` يرتفع جهد الرجل PD12 في الشريحة إلى 3.3 فولت، فيضيء الضوء الأخضر المتصل بها على اللوحة. وبعض المسجلات تتغير قيمتها بدون أن يكتب فيها أحد، مثل مسجل الحالة في المنفذ التسلسلي الذي يتغير فيه البت 7 عندما ينتهي إرسال الحرف، وهذه النقطة سوف تعود بعد قليل عندما نتحدث عن `volatile`.

وفي C نصل إلى المسجل بتحويل العنوان إلى مؤشر ثم قراءته أو الكتابة فيه، وهذا ما يفعله الماكرو الذي سنستخدمه في كل الكود:

```c
#define REG(addr) (*(volatile uint32_t *)(addr))
#define GPIOD_ODR REG(0x40020C14u)

GPIOD_ODR ^= (1u << 12);   // قلب حالة الضوء
```

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

- العنوان رقم عادي، وتحويله إلى `uint32_t *` يقول للمترجم إن في هذا العنوان قيمة بحجم 32 بت، ثم النجمة الأولى تقرأ أو تكتب القيمة نفسها.
- النوع `uint32_t` من `stdint.h` وليس `int` أو `unsigned long`، والسبب أن حجم المسجل ثابت 32 بت، وحجم `int` يختلف بين المعالجات، فلا تعتمد عليه في أي شيء يمس العتاد.
- الحرف `u` بعد الرقم يجعله بدون إشارة Unsigned، لأن إزاحة 1 إلى البت 31 في عدد بإشارة سلوك غير معرف Undefined Behavior في C.
- الكلمة `volatile` في الماكرو هي أهم كلمة في السطر، ولها قسم كامل بعد قليل.

وفي المشاريع الحقيقية لا يكتب أحد العناوين بيده، وإنما يستخدم ملف ST الرسمي الذي يعرف كل طرفية كـ `struct` يطابق ترتيب مسجلاتها، فتكتب `GPIOD->ODR ^= GPIO_ODR_OD12;`. ولكننا كتبنا العناوين هنا عمداً، لكي ترى أن هذه الملفات ليست سحراً، وإنما عناوين وإزاحات منقولة من الدليل.

## المسجلات Registers: كيف تقرأ دليل المرجع وتكتب البت الصحيح؟

لنأخذ مهمة بسيطة: إضاءة الضوء الأخضر على لوحة STM32F4 Discovery، وهي لوحة تطوير من ST عليها الشريحة STM32F407 وأربعة أضواء ومبرمج ST-LINK مدمج. ومن مخطط اللوحة نعرف أن الضوء الأخضر متصل بالرجل 12 من المنفذ D، أي PD12، وهذا موجود أيضاً في ملف وصف اللوحة في Renode الذي سنستخدمه، حيث تجد السطر `12 -> UserLED@0` تحت `gpioPortD`. والمبرمج القادم من عالم Linux يتوقع أن يكتب 1 في مسجل الخرج وينتهي الأمر، ولكن هذا لن يعمل على الشريحة الحقيقية، والسبب أن الوصول إلى الطرفية يمر بثلاث خطوات، ولكل خطوة مسجل:

1. **تشغيل الساعة Clock**: كل طرفية في الشريحة تحتاج ساعة لكي تعمل، والشريحة تبدأ بعد التشغيل وأغلب ساعات الطرفيات مطفأة لكي لا تستهلك طاقة في شيء لا تستخدمه. والمسؤول عن الساعات هو المتحكم RCC عند `0x40023800`، وفيه المسجل `AHB1ENR` على الإزاحة `0x30`، والبت 3 فيه يشغل ساعة المنفذ GPIOD، والبت 0 يشغل GPIOA. وإذا نسيت هذه الخطوة فكل كتابة في مسجلات المنفذ تذهب بدون أثر، وكل قراءة تعطي صفراً، والبرنامج لا يعطيك أي خطأ.
2. **وضع الرجل Mode**: كل رجل يمكن أن تكون دخلاً أو خرجاً أو وظيفة بديلة أو تماثلية، والمسجل `MODER` يعطي لكل رجل بتين، فالرجل 12 لها البتان 25 و24، ونريد القيمة 01 أي خرج.
3. **الخرج Output**: الآن فقط تكتب في `ODR`، والبت 12 فيه يقابل الرجل 12.

![ثلاث بطاقات للمسجلات الثلاثة: RCC_AHB1ENR والبت 3 لساعة GPIOD والبت 0 لساعة GPIOA، ثم GPIOD_MODER والبتان 25 و24 بالقيمة 01 أي خرج، مع شرح القيم الأربع للوضع، ثم GPIOD_ODR والبت 12 للضوء، مع ملاحظة أن القراءة والتعديل والكتابة ثلاث تعليمات وأن BSRR بديل آمن](https://arabroot.io/content/images/2026/11/embedded-c-02-registers-1.webp)

الخطوات الثلاث لإضاءة LED، وكل خطوة بت أو بتان في مسجل

والكتابة في البتات لها أسلوب ثابت يجب أن تحفظه، لأنك سوف تراه في كل سطر من الكود المدمج. فلكي تضبط بتاً واحداً بدون أن تمس الباقي تستخدم OR مثل `REG |= (1u << 3)`، ولكي تمسح بتاً تستخدم AND مع العكس مثل `REG &= ~(1u << 3)`، ولكي تكتب حقلاً من عدة بتات تمسحه أولاً ثم تكتب القيمة الجديدة، كما في السطر الذي يضبط وضع الرجل 12:

```c
GPIOD_MODER = (GPIOD_MODER & ~(3u << 24)) | (1u << 24);   // البتان 25:24 = 01
```

وقد يتساءل البعض: لماذا لا نكتب `GPIOD_MODER = 1u << 24` مباشرة وهو أقصر؟ والإجابة أن هذا السطر يضع صفراً في كل البتات الأخرى، أي يحول الأرجل الخمس عشرة الباقية في المنفذ إلى دخل، وإذا كان زميلك قد ضبط رجلاً منها في مكان آخر من الكود لمنفذ SPI أو لضوء آخر فسوف يتوقف عمله بدون أي رسالة. وهذا من أكثر الأخطاء شيوعاً عند من يبدأ في البرمجة المدمجة، وأصعبها في التتبع، لأن الخطأ يظهر في جزء آخر من الجهاز غير الذي عدلته.

وهناك نقطة أدق في السطر `GPIOD_ODR ^= (1u << 12)`، فهو يبدو عملية واحدة، ولكنه في الحقيقة ثلاث تعليمات: قراءة المسجل، ثم قلب البت، ثم الكتابة، وهذا ما يسمى القراءة والتعديل والكتابة Read-Modify-Write. فإذا جاءت مقاطعة Interrupt بين القراءة والكتابة وغيرت بتاً آخر في نفس المسجل، فإن كتابتك سوف تعيد القيمة القديمة لذلك البت وتمحو ما فعلته المقاطعة. ولهذا السبب صممت ST مسجلاً خاصاً اسمه `BSRR`، تكتب فيه 1 في البت 12 لكي ترفع الرجل، أو في البت 28 لكي تخفضها، بكتابة واحدة لا تقرأ شيئاً ولا تمس الأرجل الأخرى. وفي برنامجنا الصغير لا توجد مقاطعة تكتب في المنفذ D، فتركنا `^=` لأنها أوضح للقراءة، ولكن في الجهاز الحقيقي الذي تتشارك فيه المقاطعات والكود الرئيسي نفس المنفذ استخدم `BSRR` دائماً.

والمنفذ التسلسلي يحتاج خطوات أكثر بنفس المنطق: تشغيل ساعته من البت 17 في `RCC_APB1ENR`، ثم تحويل الرجل PA2 إلى وظيفة بديلة رقم 7 وهي مخرج الإرسال TX للمنفذ USART2، ثم ضبط السرعة في `BRR`، ثم تشغيل المنفذ والإرسال في `CR1`. وقيمة السرعة تحسب من تردد الساعة، فمع ساعة 16 MHz وسرعة 115200 بت في الثانية تكون القسمة 138.9، أي `0x8B` تقريباً، وهذا الرقم صحيح فقط إذا كانت الساعة فعلاً 16 MHz، وتذكر هذه الجملة لأننا سنحتاجها في المختبر.

## الكلمة volatile: لماذا يحتاجها كل كود مدمج؟

المترجم Compiler عندما يحسن الكود يفترض شيئاً منطقياً: أن قيمة المتغير لا تتغير إلا إذا غيرها الكود الذي يراه. فإذا قرأت متغيراً مرتين في حلقة ولم يكتب فيه شيء داخل الحلقة، فمن حقه أن يقرأه مرة واحدة ويحتفظ بالقيمة في مسجل المعالج، وهذا تحسين صحيح تماماً في برنامج عادي. ولكن في البرنامج المدمج توجد أشياء تغير القيم بدون أن يراها المترجم: الطرفيات التي تغير مسجلاتها بنفسها، والمقاطعات التي تقطع الكود الرئيسي في أي لحظة وتكتب في متغيرات عامة، ونقل البيانات المباشر DMA الذي يكتب في الذاكرة بدون المعالج أصلاً. والكلمة `volatile` تقول للمترجم: هذه القيمة قد تتغير من خارج ما تراه، فاقرأها من الذاكرة في كل مرة يطلبها الكود، واكتبها في كل مرة يكتبها، ولا تحذف أي وصول إليها ولا تغير ترتيبه بالنسبة لوصول آخر إلى قيمة volatile، وهذا هو التعريف في [معيار C](https://en.cppreference.com/w/c/language/volatile?ref=arabroot.io) وفي [توثيق GCC](https://gcc.gnu.org/onlinedocs/gcc/Volatiles.html?ref=arabroot.io).

وفي برنامجنا مثال واضح، فالمؤقت SysTick يولد مقاطعة كل 1 ms، ودالة المقاطعة تزيد العداد `ticks`، ودالة التأخير في الكود الرئيسي تنتظر حتى يزيد العداد بمقدار معين:

```c
volatile uint32_t ticks;
void SysTick_Handler(void) { ticks++; }

static void delay_ms(uint32_t ms) {
    uint32_t start = ticks;
    while ((ticks - start) < ms) { }
}
```

والمترجم وهو يترجم `delay_ms` لا يعرف أن `SysTick_Handler` سوف تستدعى في منتصف الحلقة، لأن لا أحد في الكود يستدعيها، وإنما يستدعيها العتاد. فإذا حذفت `volatile` فسوف يرى حلقة تقرأ قيمة لا تتغير، ويستنتج أن الشرط إما صحيح دائماً أو خاطئ دائماً، وسوف نرى في المختبر ماذا فعل GCC 14 بالضبط في هذه الحالة، والنتيجة أسوأ مما تتوقع. ولاحظ أن الطرح `ticks - start` بأعداد بدون إشارة مقصود، فعندما يصل العداد إلى أقصى قيمة ويعود إلى الصفر بعد 49.7 يوماً تقريباً يبقى الفرق صحيحاً، والمقارنة المباشرة `ticks < start + ms` تفشل في تلك اللحظة، وهذا خطأ معروف يظهر في الأجهزة التي تعمل أسابيع بدون إعادة تشغيل، أي بالضبط في جهاز مثل مسجل الحرارة.

ولكن احذر من الفهم الزائد لهذه الكلمة، فهي لا تفعل ثلاثة أشياء يظنها البعض:

- **لا تجعل العملية ذرية Atomic**: السطر `ticks++` على متغير volatile ما زال قراءة ثم زيادة ثم كتابة، فإذا كانت هناك مقاطعتان تزيدان نفس المتغير بأولويتين مختلفتين فقد تضيع زيادة، والحل تعطيل المقاطعات حول العملية أو تعليمات المعالج الذرية مثل `LDREX` و`STREX` أو أنواع `stdatomic.h`.
- **لا تمنع المعالج من إعادة الترتيب**: هي تمنع المترجم فقط، أما في المعالجات الأكبر أو مع DMA فقد تحتاج حاجز الذاكرة Memory Barrier مثل `__DMB()` في CMSIS، لكي تضمن أن البيانات وصلت إلى الذاكرة قبل أن تبدأ الطرفية بقراءتها.
- **لا تصلح للتزامن بين الخيوط على نظام تشغيل**: في برامج Linux العادية لا تستخدم volatile بدل الأقفال، وقد كتب مطورو النواة وثيقة كاملة اسمها [volatile considered harmful](https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html?ref=arabroot.io) يشرحون فيها ذلك، وقد شرحنا الأقفال في مقال [التزامن في C](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%B2%D8%A7%D9%85%D9%86-%D9%81%D9%8A-c-%D8%A7%D9%84%D8%AE%D9%8A%D9%88%D8%B7-pthreads-%D9%88%D8%A7%D9%84%D8%A7%D9%82%D9%81%D8%A7%D9%84-locks/). والفرق أن مكانها الصحيح هو الوصول إلى العتاد والمتغيرات التي تتشاركها المقاطعة مع الكود الرئيسي على نواة واحدة.

وإذا فتحت ملف `core_cm4.h` من CMSIS فستجد أن كل المسجلات معرفة بالكلمة `__IO`، وهي ماكرو قيمته `volatile`، وهذا هو السبب الذي يجعل كود ST يعمل مع أعلى مستويات التحسين.

## كود البداية Startup Code: ماذا يحدث قبل main؟

في برنامج Linux يبدأ التنفيذ من دالة اسمها `_start` تأتي من مكتبة C، تجهز البيئة ثم تستدعي `main`، وأنت لا تراها أبداً. أما في المتحكم فلا أحد يفعل ذلك، والمعالج Cortex-M عند التشغيل أو إعادة التشغيل Reset يفعل شيئين فقط، وهما موصوفان في دليل معمارية Armv7-M: يقرأ الكلمة الأولى من بداية الذاكرة ويضعها في مؤشر المكدس SP، ثم يقرأ الكلمة الثانية ويقفز إليها. وفي STM32 تكون بداية الذاكرة عند الإقلاع من الفلاش هي `0x08000000`. أي أن أول 8 بايت في الفلاش يجب أن تكون عنوان نهاية المكدس ثم عنوان أول دالة تنفذ، وبعدهما عناوين الدوال التي تعالج كل استثناء Exception وكل مقاطعة، وهذا كله يسمى جدول المقاطعات Vector Table.

وفي برنامجنا كتبنا الجدول كمصفوفة C عادية، ووضعناها في قسم خاص اسمه `.isr_vector` لكي يضعه الرابط في أول الفلاش:

```c
// Startup code: the vector table and the reset handler that prepares memory before main().
#include <stdint.h>

extern uint32_t _sidata, _sdata, _edata, _sbss, _ebss, _estack;   // defined by link.ld
int main(void);

void Reset_Handler(void) {
#ifndef SKIP_DATA_COPY
    uint32_t *src = &_sidata, *dst = &_sdata;
    while (dst < &_edata) *dst++ = *src++;          // copy .data from flash (LMA) to RAM (VMA)
#endif
    for (uint32_t *p = &_sbss; p < &_ebss; ) *p++ = 0;   // clear .bss
    main();
    for (;;) { }
}

void Default_Handler(void) { for (;;) { } }
void NMI_Handler(void)       __attribute__((weak, alias("Default_Handler")));
void HardFault_Handler(void) __attribute__((weak, alias("Default_Handler")));
void SVC_Handler(void)       __attribute__((weak, alias("Default_Handler")));
void PendSV_Handler(void)    __attribute__((weak, alias("Default_Handler")));
void SysTick_Handler(void)   __attribute__((weak, alias("Default_Handler")));

// The first word is the initial stack pointer, the second the reset address; the core reads both at power-up.
__attribute__((section(".isr_vector"), used))
const void *const vector_table[16] = {
    &_estack, Reset_Handler, NMI_Handler, HardFault_Handler,
    0, 0, 0, 0, 0, 0, 0, SVC_Handler, 0, 0, PendSV_Handler, SysTick_Handler,
};
```

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

- الخانة 0 هي `&_estack` أي نهاية الذاكرة، لأن المكدس في Arm ينمو للأسفل، فيبدأ من أعلى عنوان وينزل.
- الخانة 1 هي `Reset_Handler`، والخانة 3 لخطأ `HardFault`، والخانة 15 للمؤقت `SysTick`، وترتيب الخانات ثابت في المعمارية، وبعد الخانة 15 تبدأ مقاطعات الطرفيات الخاصة بكل شريحة، ولم نضفها لأننا لا نستخدمها.
- كل الدوال التي لم نكتبها تشير إلى `Default_Handler` عبر `weak, alias`، أي أن أي ملف آخر يعرف دالة بنفس الاسم يحل محلها تلقائياً، وهذا ما فعله `main.c` مع `SysTick_Handler`. وهذه نفس الطريقة التي تستخدمها ملفات البداية من ST وCMSIS.
- الكلمة `used` تمنع المترجم من حذف المصفوفة، فلا أحد في الكود يقرؤها، والذي يقرؤها هو المعالج.

ثم يأتي `Reset_Handler`، وهو الكود الذي يفعل ما كانت تفعله مكتبة C ونظام التشغيل لك، وأهم عمل له شيئان. الأول نسخ القسم `.data`، فالمتغير العام الذي له قيمة أولى مثل `uint32_t boot_magic = 0xC0FFEEu;` يجب أن يكون في الذاكرة SRAM لأن الكود يكتب فيه، ولكن الذاكرة SRAM تفقد محتواها عند انقطاع الكهرباء، فأين تحفظ القيمة الأولى؟ تحفظ في الفلاش، ثم ينسخها كود البداية إلى مكانها في SRAM قبل `main`. والثاني تصفير القسم `.bss`، لأن معيار C يعد بأن كل متغير عام بدون قيمة أولى يبدأ صفراً، والذاكرة SRAM بعد التشغيل فيها قيم عشوائية، فلا بد أن يكتب أحد الأصفار. وبعد ذلك فقط يصبح كود C صحيحاً، ويستدعي `main`، وإذا عادت `main` لأي سبب يدخل في حلقة لا تنتهي، لأنه لا يوجد نظام تشغيل يعود إليه.

![خمس خطوات من اليمين إلى اليسار: المعالج يقرأ 0x20020000 من أول الفلاش ويضعه في SP، ثم يقرأ عنوان Reset_Handler 0x08000309، ثم ينسخ data من 0x080003d4 إلى 0x20000000، ثم يصفر bss من 0x20000004 إلى 0x2000000c، ثم يستدعي main وتأتي مقاطعة SysTick من الخانة 15، وتحتها تجربة حذف النسخ التي طبعت boot_magic صفراً، والجدول كما هو في الفلاش بترتيب Little Endian](https://arabroot.io/content/images/2026/11/embedded-c-03-boot-1.webp)

الإقلاع بالعناوين الحقيقية من برنامجنا كما أخرجها objdump وnm

وكثير من الفرق تكتب كود البداية بلغة التجميع Assembly، وهذا ما تجده في ملفات `startup_stm32f407xx.s` من ST، ولكن معالجات Cortex-M صممت لكي يكتب هذا الكود بلغة C بالكامل، لأن المعالج يضبط المكدس بنفسه من الخانة الأولى قبل أن ينفذ أي تعليمة، وهذا من الفروق المهمة بينها وبين معالجات Arm الأقدم، وتجد مثالاً رسمياً على ذلك في صفحة [Startup File بلغة C](https://arm-software.github.io/CMSIS%5F6/latest/Core/startup%5Fc%5Fpg.html?ref=arabroot.io) في توثيق CMSIS 6\. وفي الأجهزة الحقيقية يضيف كود البداية أشياء أخرى قبل `main`، مثل تشغيل وحدة الأرقام العشرية FPU، وضبط الساعة على التردد الكامل، واستدعاء المشيدات Constructors إذا كان في المشروع C++.

## ملف الربط Linker Script: من يقرر أين يوضع كل شيء؟

عندما تترجم برنامجاً لـ Linux فالرابط يعرف أين يضع الكود والمتغيرات، لأن نظام التشغيل يعطي كل برنامج نفس المساحة الافتراضية. أما في المتحكم فكل شريحة لها خريطتها، والرابط لا يعرف أن الفلاش في هذه الشريحة يبدأ من `0x08000000` وحجمه 1 MB، ولا أن جدول المقاطعات يجب أن يكون أول شيء فيه، ولذلك تكتب له ملف ربط Linker Script يصف ذلك. وهذا الملف بلغة خاصة بأداة `ld` من GNU، موثقة في [دليل ld](https://sourceware.org/binutils/docs/ld/Scripts.html?ref=arabroot.io)، وملفنا كما يلي:

```text
/* Linker script for STM32F407VG: 1 MB flash at 0x08000000, 128 KB SRAM at 0x20000000 */
ENTRY(Reset_Handler)

MEMORY
{
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 1024K
    RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 128K
}

_estack = ORIGIN(RAM) + LENGTH(RAM);    /* the stack grows down from the end of RAM */

SECTIONS
{
    .isr_vector : { KEEP(*(.isr_vector)) } > FLASH   /* must sit at address 0 of flash */

    .text : { *(.text*) *(.rodata*) . = ALIGN(4); } > FLASH

    _sidata = LOADADDR(.data);          /* where the initial values are stored in flash */
    .data : { _sdata = .; *(.data*) . = ALIGN(4); _edata = .; } > RAM AT > FLASH

    .bss (NOLOAD) : { _sbss = .; *(.bss*) *(COMMON) . = ALIGN(4); _ebss = .; } > RAM
}
```

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

- الجزء `MEMORY` يصف المناطق الحقيقية في الشريحة، بعنوان البداية والحجم، وهو الجزء الوحيد الذي يتغير غالباً بين شريحة وأخرى من نفس العائلة، وتفاصيله في صفحة [MEMORY](https://sourceware.org/binutils/docs/ld/MEMORY.html?ref=arabroot.io).
- الرمز `_estack` يحسب من نهاية الذاكرة، والرموز التي يعرفها ملف الربط مثل `_sdata` و`_ebss` لا تأخذ مكاناً في الذاكرة، وإنما هي عناوين يقرؤها كود البداية، ولهذا كتبناها في C على شكل `extern uint32_t _sdata;` واستخدمنا عنوانها `&_sdata` وليس قيمتها.
- `KEEP` حول جدول المقاطعات تمنع الرابط من حذفه مع الخيار `--gc-sections` الذي يحذف كل قسم لا يشير إليه أحد.
- السطر الأهم هو `> RAM AT > FLASH` في القسم `.data`، فهو يقول: عنوان التشغيل VMA لهذا القسم في الذاكرة، وعنوان التحميل LMA في الفلاش. والكود يستخدم عنوان التشغيل عندما يقرأ المتغير، والملف الذي يكتب في الفلاش يحمل البايتات في عنوان التحميل، وكود البداية ينقلها من الثاني إلى الأول، وهذه العلاقة موثقة في صفحة [Output Section LMA](https://sourceware.org/binutils/docs/ld/Output-Section-LMA.html?ref=arabroot.io).
- القسم `.bss` عليه `NOLOAD`، أي لا يحفظ شيء منه في الفلاش، لأن محتواه أصفار يكتبها كود البداية، وهذا هو الفرق بين متغير عام بقيمة أولى صفر ومتغير بقيمة أخرى: الأول لا يكلفك شيئاً من الفلاش.

والسؤال الذي يأتي بعد ذلك: أين الكومة Heap؟ والإجابة أنه لا توجد كومة في ملفنا، لأننا لا نستخدم `malloc`، وهذا هو المعتاد في الأجهزة الصغيرة. فالذاكرة الديناميكية في جهاز يعمل سنوات بدون إعادة تشغيل تعني خطر التجزئة Fragmentation، أي أن تكون الذاكرة الحرة كافية في مجموعها ولكنها مقسمة إلى قطع صغيرة لا تكفي أي واحدة منها للطلب، ولذلك تمنع قواعد MISRA استخدام `malloc` بعد مرحلة التهيئة، وتحجز الفرق كل الذاكرة بشكل ثابت عند الترجمة، فتعرف من ملف الخريطة قبل التشغيل هل يكفي الجهاز أم لا.

![عمودان: الفلاش عند 0x08000000 وفيه isr_vector بحجم 64 بايت ثم text بحجم 916 بايت ثم نسخة data عند 0x080003d4، والذاكرة SRAM عند 0x20000000 وفيها data ثم bss بحجم 8 بايت ثم المكدس ينزل من 0x20020000، وتحتهما مخرج size بالقيم 980 و4 و8، وسطر من ملف الخريطة يبين عنوان التحميل](https://arabroot.io/content/images/2026/11/embedded-c-04-linker-1.webp)

مكان كل قسم في الفلاش والذاكرة، والفرق بين عنوان التحميل LMA وعنوان التشغيل VMA

## المختبر Lab: برنامج كامل على STM32F407 في Renode

الآن نجمع كل ما سبق في برنامج واحد يعمل. واختيار المحاكي Emulator هنا ليس بديلاً مؤقتاً عن اللوحة، وإنما هو الطريقة التي تعمل بها فرق كثيرة اليوم، فالمحاكي [Renode](https://renode.io/?ref=arabroot.io) مفتوح المصدر من شركة Antmicro يحاكي الشريحة كاملة مع طرفياتها، المنافذ والمنفذ التسلسلي والمؤقتات، ويشغل نفس ملف ELF الذي ستكتبه في الشريحة الحقيقية بدون أي تعديل، ويعطيك ما لا تعطيك اللوحة: وقتاً افتراضياً Virtual Time يمكنك إيقافه وتكراره بالضبط، وسجلاً لكل تغير في حالة الأرجل، وتشغيلاً في خط CI بدون أن يوصل أحد سلكاً. وسوف نستخدم وصف لوحة STM32F4 Discovery الذي يأتي مع Renode في الملف [stm32f4\_discovery-kit.repl](https://github.com/renode/renode/blob/master/platforms/boards/stm32f4%5Fdiscovery-kit.repl?ref=arabroot.io).

والبرنامج يشغل الساعات، ويضبط المنفذ التسلسلي والضوء، ويبرمج SysTick لمقاطعة كل 1 ms، ثم يطبع سطراً يبين القيمة الأولى لمتغير من `.data` ومتغير من `.bss`، ثم يقلب الضوء كل 500 ms ويطبع الوقت. والملف الكامل كما يلي:

```c
// Bare-metal STM32F407 (Cortex-M4): blink the green LED on PD12 and print over USART2.
// No HAL, no CMSIS: every register address comes from the STM32F407 reference manual (RM0090).
#include <stdint.h>

#define REG(addr) (*(volatile uint32_t *)(addr))

#define RCC_AHB1ENR  REG(0x40023830u)   // bit 0 GPIOA, bit 3 GPIOD
#define RCC_APB1ENR  REG(0x40023840u)   // bit 17 USART2
#define GPIOA_MODER  REG(0x40020000u)
#define GPIOA_AFRL   REG(0x40020020u)
#define GPIOD_MODER  REG(0x40020C00u)
#define GPIOD_ODR    REG(0x40020C14u)
#define USART2_SR    REG(0x40004400u)   // bit 7 TXE
#define USART2_DR    REG(0x40004404u)
#define USART2_BRR   REG(0x40004408u)
#define USART2_CR1   REG(0x4000440Cu)   // bit 13 UE, bit 3 TE
#define SYST_CSR     REG(0xE000E010u)
#define SYST_RVR     REG(0xE000E014u)
#define SYST_CVR     REG(0xE000E018u)

#ifdef NO_VOLATILE
uint32_t ticks;                    // experiment: the compiler may keep it in a register
#else
volatile uint32_t ticks;           // written by SysTick_Handler, read by main: must be volatile
#endif
uint32_t boot_magic = 0xC0FFEEu;   // initialised global: lives in .data, copied from flash at reset
uint32_t toggles;                  // zero global: lives in .bss, cleared at reset
static const char banner[] = "embedded-c lab: STM32F407 bare metal\r\n";   // .rodata, stays in flash

void SysTick_Handler(void) { ticks++; }

static void uart_putc(char c) {
    while (!(USART2_SR & (1u << 7))) { }   // wait until the transmit register is empty
    USART2_DR = (uint32_t)c;
}
static void uart_puts(const char *s) { while (*s) uart_putc(*s++); }
static void uart_hex(uint32_t v) {
    uart_puts("0x");
    for (int i = 28; i >= 0; i -= 4) uart_putc("0123456789ABCDEF"[(v >> i) & 0xF]);
}
static void uart_dec(uint32_t v) {
    char b[11]; int i = 10; b[i] = 0;
    do { b[--i] = (char)('0' + v % 10); v /= 10; } while (v);
    uart_puts(&b[i]);
}

static void delay_ms(uint32_t ms) {
    uint32_t start = ticks;
    while ((ticks - start) < ms) { }       // without volatile this read can be hoisted out of the loop
}

int main(void) {
#ifndef NO_RCC
    RCC_AHB1ENR |= (1u << 0) | (1u << 3);  // clock for GPIOA and GPIOD
    RCC_APB1ENR |= (1u << 17);             // clock for USART2
#endif

    GPIOA_MODER = (GPIOA_MODER & ~(3u << 4)) | (2u << 4);      // PA2 alternate function
    GPIOA_AFRL  = (GPIOA_AFRL & ~(0xFu << 8)) | (7u << 8);     // AF7 = USART2_TX
    USART2_BRR  = 0x8B;                                        // 16 MHz HSI / 115200 baud
    USART2_CR1  = (1u << 13) | (1u << 3);                      // UE + TE

    GPIOD_MODER = (GPIOD_MODER & ~(3u << 24)) | (1u << 24);    // PD12 output

    SYST_RVR = 16000u - 1u;                // 1 ms at 16 MHz
    SYST_CVR = 0;
    SYST_CSR = 7;                          // processor clock, interrupt, enable

    uart_puts(banner);
    uart_puts("boot_magic="); uart_hex(boot_magic);
    uart_puts(" toggles="); uart_dec(toggles); uart_puts("\r\n");

    for (;;) {
        delay_ms(500);
        GPIOD_ODR ^= (1u << 12);
        toggles++;
        uart_puts("t="); uart_dec(ticks); uart_puts("ms led=");
        uart_puts((GPIOD_ODR & (1u << 12)) ? "on" : "off");
        uart_puts(" toggles="); uart_dec(toggles); uart_puts("\r\n");
    }
}
```

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

- كل عنوان مسجل مأخوذ من الدليل، وبجانبه البت الذي نستخدمه، وهذا أسلوب جيد حتى عندما تستخدم ملفات ST، لأن من يراجع الكود يحتاج أن يعرف لماذا كتبت هذه القيمة.
- المتغيرات الثلاثة `ticks` و`boot_magic` و`toggles` وضعناها عمداً لكي نرى الأقسام الثلاثة: `ticks` في `.bss` وتتغير من المقاطعة، و`boot_magic` في `.data`، و`toggles` في `.bss` وقيمتها الأولى صفر.
- الثابت `banner` عليه `const`، فيبقى في الفلاش ولا يأخذ شيئاً من الذاكرة، وهذا فرق مهم في الأجهزة الصغيرة: جدول بحجم 4 KB بدون `const` يعني 4 KB من الفلاش و4 KB من الذاكرة.
- الطباعة تنتظر البت 7 في `USART2_SR` قبل كل حرف، وهذه طريقة الاستطلاع Polling، وهي بسيطة ولكنها تضيع وقت المعالج في الانتظار، وفي الأجهزة الحقيقية تستخدم المقاطعات أو DMA، وهذا موضوع مقالات قادمة في هذه المرحلة.
- قيمة `SYST_RVR` هي 15999 لأن المؤقت يعد من القيمة إلى الصفر، فيعطي مقاطعة كل 16000 نبضة، أي كل 1 ms إذا كانت الساعة 16 MHz.

وملف البناء يترجم الملفين معاً ويطبع الحجم:

```makefile
CC      = arm-none-eabi-gcc
CFLAGS  = -mcpu=cortex-m4 -mthumb -O2 -g -std=c11 -Wall -Wextra -ffreestanding -ffunction-sections -fdata-sections $(EXTRA)
LDFLAGS = -T link.ld -nostdlib -nostartfiles -Wl,--gc-sections -Wl,-Map=$(OUT).map
OUT    ?= blink

$(OUT).elf: main.c startup.c link.ld
	$(CC) $(CFLAGS) $(LDFLAGS) main.c startup.c -o $@
	arm-none-eabi-size $@
	arm-none-eabi-objcopy -O binary $@ $(OUT).bin

clean:
	rm -f *.elf *.bin *.map
```

والخيارات هنا لها أسباب: `-mcpu=cortex-m4 -mthumb` لتوليد تعليمات المعالج الصحيح، و`-ffreestanding` لكي لا يفترض المترجم وجود مكتبة C كاملة، و`-ffunction-sections -fdata-sections` مع `--gc-sections` لكي يضع كل دالة ومتغير في قسم منفصل ثم يحذف الرابط ما لا يستخدم، وهذا وحده يوفر الكثير في المشاريع الكبيرة، وتفاصيلها في [خيارات Arm في GCC](https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html?ref=arabroot.io). والخيار `-g` يضيف معلومات التصحيح، ولا تقلق من حجمها، فهي في أقسام `.debug_*` التي لا تكتب في الفلاش، وسوف نحتاجها في [مقال التصحيح](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/).

وملف Renode الذي يشغل البرنامج قصير:

```text
# Renode: STM32F4 Discovery board, our ELF, UART to a file, LED changes in the log, 1.2 virtual seconds
$elf?=@/work/blink/blink.elf
$uart?=@/work/out/uart.txt
mach create "disco"
machine LoadPlatformDescription @platforms/boards/stm32f4_discovery-kit.repl
$hz?=72000000
sysbus.nvic Frequency $hz
sysbus LoadELF $elf
sysbus.usart2 CreateFileBackend $uart true
logLevel -1 sysbus.gpioPortD.UserLED
emulation RunFor "1.2"
machine ElapsedVirtualTime
quit
```

وكل خطوات المختبر في ملف واحد `lab/run.sh` يعمل داخل الـ Container، وتشغيله كما يلي:

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

### البناء ومخرج size: كم يأخذ البرنامج من الفلاش؟

والمخرج الأول هو البناء نفسه:

```text
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -O2 -g -std=c11 -Wall -Wextra -ffreestanding -ffunction-sections -fdata-sections  -T link.ld -nostdlib -nostartfiles -Wl,--gc-sections -Wl,-Map=blink.map main.c startup.c -o blink.elf
arm-none-eabi-size blink.elf
   text	   data	    bss	    dec	    hex	filename
    980	      4	      8	    992	    3e0	blink.elf
arm-none-eabi-objcopy -O binary blink.elf blink.bin
```

والسطر الذي يهمك هو مخرج `arm-none-eabi-size`، وهو أول رقم ينظر إليه مهندس البرمجيات المدمجة بعد كل تغيير، وتفاصيل أعمدته في [توثيق size](https://sourceware.org/binutils/docs/binutils/size.html?ref=arabroot.io):

- `text` بقيمة 980 بايت: الكود والثوابت وجدول المقاطعات، وكلها في الفلاش.
- `data` بقيمة 4 بايت: المتغير `boot_magic`، وهذا الرقم يحسب مرتين، مرة في الفلاش لأن قيمته الأولى محفوظة هناك، ومرة في الذاكرة.
- `bss` بقيمة 8 بايت: المتغيران `ticks` و`toggles`، في الذاكرة فقط.
- فيكون الفلاش المستهلك `text + data` أي 984 بايت من 1 MB، والذاكرة `data + bss` أي 12 بايت من 128 KB، بدون المكدس الذي لا يظهر في هذا الرقم أبداً، وهذه نقطة مهمة: `size` لا يعرف كم يحتاج برنامجك من المكدس، وهذا ما يسبب أغلب مشاكل الذاكرة في الأجهزة الحقيقية، وأداة GCC لذلك هي الخيار `-fstack-usage` الذي يكتب حجم مكدس كل دالة في ملف.

والملف `blink.bin` هو البايتات الخام التي تكتب في الفلاش، وهو ما يرسله المبرمج إلى الشريحة، أما `blink.elf` ففيه نفس البايتات ومعها العناوين والرموز ومعلومات التصحيح، وهو ما يقرؤه Renode والمصحح GDB.

### الأقسام Sections ثم الرموز Symbols: أين ذهب كل شيء؟

والآن نتحقق أن الرابط فعل ما طلبناه في ملف الربط، والأمر `objdump -h` يعرض الأقسام:

```text
Idx Name          Size      VMA       LMA       File off  Algn
  0 .isr_vector   00000040  08000000  08000000  00010000  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  1 .text         00000394  08000040  08000040  00010040  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .data         00000004  20000000  080003d4  00020000  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  3 .bss          00000008  20000004  080003d8  00020004  2**2
                  ALLOC
  4 .debug_info   00000696  00000000  00000000  00020004  2**0
                  CONTENTS, READONLY, DEBUGGING, OCTETS
  5 .debug_abbrev 000002f6  00000000  00000000  0002069a  2**0
                  CONTENTS, READONLY, DEBUGGING, OCTETS
  6 .debug_loclists 000001cf  00000000  00000000  00020990  2**0
                  CONTENTS, READONLY, DEBUGGING, OCTETS
  7 .debug_aranges 00000058  00000000  00000000  00020b5f  2**0
```

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

- `.isr_vector` حجمه `0x40` أي 64 بايت، أي 16 كلمة، وهو بالضبط حجم المصفوفة، وعنوانه `08000000` أي أول الفلاش.
- `.text` يبدأ من `08000040` مباشرة بعد الجدول، وحجمه `0x394` أي 916 بايت، ومع الجدول يكون المجموع 980، وهو رقم `text` في مخرج `size`.
- `.data` هو القسم الوحيد الذي يختلف فيه VMA عن LMA: يعمل في `20000000` ويحفظ في `080003d4`، أي بعد نهاية `.text` مباشرة.
- `.bss` عليه `ALLOC` فقط بدون `CONTENTS` أو `LOAD`، أي أنه يحجز مكاناً في الذاكرة ولا يحمل أي بايت في الملف.
- أقسام `.debug_*` عنوانها صفر وعليها `DEBUGGING`، وهي في ملف ELF فقط ولا تصل إلى الشريحة.

ثم الرموز مرتبة بالعنوان مع أحجامها، بالأمر `nm -n -S`:

```text
08000000 00000040 R vector_table
08000040 0000001e t uart_puts
08000060 00000010 T SysTick_Handler
08000070 00000294 T main
08000304 00000002 T Default_Handler
08000304 00000002 W HardFault_Handler
08000304 00000002 W NMI_Handler
08000304 00000002 W PendSV_Handler
08000304 00000002 W SVC_Handler
08000308 0000005c T Reset_Handler
080003ac 00000027 t banner
080003d4 A _sidata
20000000 D _sdata
20000000 00000004 D boot_magic
20000004 D _edata
20000004 B _sbss
20000004 00000004 B toggles
20000008 00000004 B ticks
2000000c B _ebss
20020000 R _estack
```

وهذا المخرج هو خريطة برنامجك الحقيقية: `main` في `08000070` وحجمها `0x294` أي 660 بايت، وهي أكبر من المتوقع لأن المترجم أدخل فيها الدوال الصغيرة `uart_putc` و`uart_dec` و`uart_hex` و`delay_ms`، ولذلك لا تظهر في القائمة، أما `uart_puts` فبقيت لأنها تستدعى من أماكن كثيرة. ولاحظ أن خمس دوال لها نفس العنوان `08000304`، وهي `Default_Handler` والأسماء المستعارة الأربعة، والحرف `W` يعني رمزاً ضعيفاً Weak، و`T` رمزاً في الكود، و`D` في `.data`، و`B` في `.bss`، و`R` قيمة للقراءة فقط. والمتغيرات في الذاكرة جاءت متتالية كما رسمنا: `boot_magic` ثم `toggles` ثم `ticks`، وآخرها ينتهي عند `2000000c` وهو `_ebss`.

وأول 16 كلمة في الفلاش، أي جدول المقاطعات كما سيقرؤه المعالج:

```text
 8000000 00000220 09030008 05030008 05030008  ... ............
 8000010 00000000 00000000 00000000 00000000  ................
 8000020 00000000 00000000 00000000 05030008  ................
 8000030 00000000 00000000 05030008 61000008  ............a...
```

والكلمات مكتوبة بترتيب البايتات في الذاكرة، والمعالج يعمل بترتيب Little Endian، أي أن البايت الأصغر أولاً، فالكلمة الأولى `00000220` تقرأ `0x20020000` وهي `_estack`، والثانية `09030008` تقرأ `0x08000309`، وهو عنوان `Reset_Handler` الذي رأيناه في `nm` وهو `08000308` مع 1 في آخر بت. وهذا البت ليس خطأ، وإنما هو الطريقة التي يعرف بها المعالج أن الكود بتعليمات Thumb، ومعالجات Cortex-M لا تعرف غيرها، فإذا كان آخر بت صفراً في أي عنوان في الجدول فسوف يحدث خطأ HardFault عند أول انتقال إليه. والخانة الأخيرة `61000008` هي `0x08000061` أي `SysTick_Handler`، وبين ذلك ترى `05030008` وهو `Default_Handler`.

### ملف الخريطة Map File: السجل الكامل لقرارات الرابط

والخيار `-Wl,-Map=blink.map` جعل الرابط يكتب ملفاً نصياً فيه كل قراراته: أي ملف دخل، وأي قسم حذف، وأين وضع كل رمز. وهو أول ملف تفتحه عندما يقول لك الرابط إن الفلاش امتلأ، أو عندما تريد أن تعرف لماذا زاد حجم البرنامج 3 KB بعد تعديل صغير. وأوله وصف الذاكرة كما فهمها الرابط من ملفنا:

```text
Memory Configuration

Name             Origin             Length             Attributes
FLASH            0x08000000         0x00100000         xr
RAM              0x20000000         0x00020000         xrw
*default*        0x00000000         0xffffffff

Linker script and memory map
77:.data           0x20000000        0x4 load address 0x080003d4
78-                0x20000000                        _sdata = .
79- *(.data*)
80- .data.boot_magic
81-                0x20000000        0x4 /tmp/ccj5xdRO.o
82-                0x20000000                boot_magic
83-                0x20000004                        . = ALIGN (0x4)
```

والجزء الأول يعيد عليك ما كتبته في `MEMORY` بالأرقام الست عشرية، `0x00100000` أي 1 MB و`0x00020000` أي 128 KB، وهذا مفيد لكي تتأكد أن الرابط قرأ الملف الصحيح، فكثير من المشاريع فيها أكثر من ملف ربط لشرائح مختلفة. والجزء الثاني يبين القسم `.data` وعنوان تحميله، ثم من أين جاء كل متغير فيه، فترى `.data.boot_magic` وهو اسم القسم الذي أنشأه الخيار `-fdata-sections` لهذا المتغير وحده. واسم الملف `/tmp/cciqX7W8.o` مؤقت لأننا ترجمنا وربطنا بأمر واحد، وفي المشاريع الكبيرة تجد هنا اسم الملف الحقيقي واسم المكتبة، وهذا ما يجعل ملف الخريطة أداة البحث الأولى عن «من أدخل هذه الدالة الكبيرة»، فقد تجد مثلاً أن استدعاء واحداً لـ `printf` أدخل 20 KB من مكتبة newlib لدعم الأرقام العشرية.

### التشغيل في Renode: الضوء والمنفذ التسلسلي

والآن نشغل الملف في Renode لمدة 1.2 ثانية افتراضية، ونطلب منه أن يكتب في السجل كل تغير في حالة الضوء، وأن يحفظ مخرج المنفذ التسلسلي في ملف. وكان هذا المخرج في أول تشغيل:

```text
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[NOISY] gpioPortD.UserLED: LED state changed to True
[NOISY] gpioPortD.UserLED: LED state changed to False
[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-c lab: STM32F407 bare metal
boot_magic=0x00C0FFEE toggles=0
t=500ms led=on toggles=1
t=1000ms led=off toggles=2
t=1500ms led=on toggles=3
t=2000ms led=off toggles=4
t=2500ms led=on toggles=5
t=3000ms led=off toggles=6
t=3500ms led=on toggles=7
t=4000ms led=off toggles=8
t=4500ms led=on toggles=9
t=5000ms led=off toggles=10
```

والبرنامج يعمل، فالسطر الأول هو `banner` من الفلاش، والسطر الثاني يبين أن `boot_magic` وصلت بقيمتها `0x00C0FFEE`، أي أن نسخ `.data` نجح، وأن `toggles` بدأت صفراً، أي أن تصفير `.bss` نجح. ولكن انظر إلى الأرقام: عشرة تغيرات في حالة الضوء خلال 1.2 ثانية، وآخر سطر يقول `t=5000ms`، أي أن البرنامج يظن أنه مر خمس ثوان، والمفروض أن نرى تبديلين فقط عند 500 و1000 ms. فالبرنامج أسرع من الحقيقة بنسبة 4.5 مرة تقريباً.

### مشكلة حقيقية: الساعة Clock التي افترضناها خطأ

والسبب ليس في Renode ولا في الكود، وإنما في افتراض واحد: نحن برمجنا SysTick على 16000 نبضة لكل ملي ثانية لأن دليل المرجع RM0090 يقول إن الشريحة تبدأ بعد التشغيل على المذبذب الداخلي HSI بتردد 16 MHz، ولم نغير الساعة في الكود. أما ملف وصف المعالج في Renode، [stm32f4.repl](https://github.com/renode/renode/blob/master/platforms/cpus/stm32f4.repl?ref=arabroot.io)، ففيه السطر `systickFrequency: 72000000`، أي أن المحاكي يعد نبضات SysTick بتردد 72 MHz، وهو تردد شائع في البرامج التي تضبط الساعة على مذبذب خارجي، والنسبة 72 على 16 هي 4.5 بالضبط، وهي ما رأيناه. وفي اللوحة الحقيقية كانت ستحدث نفس المشكلة بالعكس لو أن كود البداية رفع الساعة إلى 168 MHz ونسينا أن نغير قيمة SysTick، فيصبح التأخير أقصر بعشر مرات، وتصبح سرعة المنفذ التسلسلي خاطئة فتظهر على الشاشة حروف غريبة بدل النص.

والحل أن نجعل المحاكي يطابق الشريحة الحقيقية بعد التشغيل، وNVIC في Renode له خاصية اسمها `Frequency` يمكن ضبطها من ملف التشغيل، ولذلك أضفنا إلى `run.resc` المتغير `$hz` والسطر `sysbus.nvic Frequency $hz`، ثم شغلناه بالقيمة 16000000:

```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-c lab: STM32F407 bare metal
boot_magic=0x00C0FFEE toggles=0
t=500ms led=on toggles=1
t=1000ms led=off toggles=2
```

والآن تبديلان فقط، عند 500 و1000 ms، والمحاكي يقول إن الوقت الافتراضي المنقضي `00:00:01.200000000`، أي أن «ملي ثانية» برنامجنا صارت ملي ثانية حقيقية. والدرس هنا أكبر من Renode: كل توقيت في البرنامج المدمج مشتق من ساعة، والمؤقتات وسرعة المنفذ التسلسلي ومعدل قراءة الحساسات كلها أرقام تحسبها من تردد تفترضه، فاجعل التردد ثابتاً معرفاً في مكان واحد في الكود مثل `#define SYSCLK_HZ 16000000u`، واحسب منه كل القيم بدل أن تكتب 16000 و`0x8B` بيدك كما فعلنا، واجعل بيئة المحاكاة في CI تطابق الساعة التي يضبطها كود البداية. وكل اختبار توقيت يمر في المحاكي بساعة خاطئة هو اختبار لا يعني شيئاً.

![ثلاث بطاقات: مع ساعة المنصة 72 MHz عشرة تبديلات في 1.2 ثانية وآخر سطر t=5000ms، وبعد الضبط على 16 MHz تبديلان عند 500 و1000 ms، والدرس أن كل التوقيتات مشتقة من الساعة](https://arabroot.io/content/images/2026/11/embedded-c-06-clock-1.webp)

نفس ملف ELF في تشغيلين، والفرق الوحيد تردد ساعة SysTick في المحاكي

### ماذا يحدث إذا حذفنا volatile؟

الآن نجرب ما شرحناه في قسم `volatile`، ونبني نسخة ثانية بالخيار `-DNO_VOLATILE`، وهي نفس الكود بالضبط ولكن `ticks` بدون الكلمة. وأول ما تلاحظه أن البرنامج صغر:

```text
   text	   data	    bss	    dec	    hex	filename
    580	      4	      8	    592	    250	novol.elf
[Domain = Elapsed Virtual Time: 00:00:01.200000000
--- uart:
embedded-c lab: STM32F407 bare metal
boot_magic=0x00C0FFEE toggles=0
```

فالقسم `text` نزل من 980 إلى 580 بايت، أي اختفت 400 بايت من الكود بحذف كلمة واحدة، والمحاكي لم يسجل أي تغير في الضوء، والمنفذ التسلسلي طبع أول سطرين ثم سكت للأبد. ولكي نفهم ماذا حدث نفتح الكود الآلي بالأمر `objdump -d -S` الذي يضع سطر C فوق التعليمات التي ولدها:

```text
    uart_puts(&b[i]);
 800014c:	add	r3, sp, #4
 800014e:	add	r0, r3
 8000150:	bl	8000040 <uart_puts>
    uart_puts(" toggles="); uart_dec(toggles); uart_puts("\r\n");
 8000154:	ldr	r0, [pc, #44]	@ (8000184 <main+0x114>)
 8000156:	bl	8000040 <uart_puts>

    for (;;) {
        delay_ms(500);
 800015a:	b.n	800015a <main+0xea>
```

والسطر `800015a: b.n 800015a` هو تعليمة تفرع Branch إلى نفس العنوان، أي حلقة لا نهائية من تعليمة واحدة. فالمترجم رأى أن `ticks` لا تتغير داخل الحلقة في `delay_ms`، فاستنتج أن `ticks - start` تساوي صفراً دائماً، وأن صفراً أقل من 500 دائماً، أي أن الحلقة لا تنتهي أبداً، ومعيار C يسمح له بذلك. ثم استنتج شيئاً ثانياً: إذا كانت الحلقة لا تنتهي فكل ما بعدها لن ينفذ أبداً، فحذفه كله: قلب الضوء، وزيادة `toggles`، والطباعة، وهذه هي الـ 400 بايت. وقارن ذلك بالنسخة الصحيحة:

```text
    while (!(USART2_SR & (1u << 7))) { }   // wait until the transmit register is empty
 800017e:	mov.w	r3, #1073758208	@ 0x40004000
    uint32_t start = ticks;
 8000182:	ldr.w	r7, [lr]
    while ((ticks - start) < ms) { }       // without volatile this read can be hoisted out of the loop
 8000186:	ldr.w	r2, [lr]
 800018a:	subs	r2, r2, r7
 800018c:	cmp.w	r2, #500	@ 0x1f4
 8000190:	bcc.n	8000186 <main+0x116>
```

وهنا ترى التعليمة `ldr.w r2, [lr]` عند `8000186` داخل الحلقة، أي قراءة `ticks` من الذاكرة في كل دورة، ثم الطرح والمقارنة بـ 500، ثم `bcc.n` التي تعود إلى القراءة ما دام الفرق أصغر. وهذا هو كل ما تفعله `volatile`: قراءة في كل مرة. وأخطر ما في هذا الخطأ أنه لا يظهر مع `-O0`، لأن المترجم بدون تحسين يقرأ كل متغير من الذاكرة في كل مرة، فيعمل البرنامج أثناء التطوير، ثم يتجمد في نسخة الإنتاج التي تبنى بـ `-O2` أو `-Os`، ولهذا تجد مطورين يقولون إن «التحسين يفسد الكود»، والحقيقة أن الكود كان خاطئاً من البداية والتحسين كشفه فقط.

![مقارنة بين عمودين: مع volatile حلقة تقرأ ticks من الذاكرة بالتعليمة ldr.w ثم تطرح وتقارن بـ 500 والمخرج سطران للضوء، وبدون volatile تعليمة واحدة b.n تقفز إلى نفسها وحذف المترجم كل ما بعدها والمخرج توقف بعد سطر البداية، وتحتهما القاعدة أن كل متغير تغيره مقاطعة أو طرفية يحتاج volatile ولكنها لا تجعل العملية ذرية](https://arabroot.io/content/images/2026/11/embedded-c-05-volatile-1.webp)

نفس دالة التأخير بعد الترجمة بـ GCC 14.2 و-O2، مع volatile وبدونها

### ماذا يحدث إذا نسي كود البداية نسخ data؟

والتجربة الثالثة على كود البداية نفسه، فنبني نسخة بالخيار `-DSKIP_DATA_COPY` الذي يحذف حلقة النسخ من `Reset_Handler`، وهذا يحدث في الواقع عندما يكتب أحدهم كود بداية جديداً لشريحة جديدة وينسى خطوة، أو عندما يغير أسماء الرموز في ملف الربط ولا يغيرها في كود البداية:

```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-c lab: STM32F407 bare metal
boot_magic=0x00000000 toggles=0
t=500ms led=on toggles=1
t=1000ms led=off toggles=2
```

والبرنامج يعمل والضوء يتغير والتوقيت صحيح، ولا يوجد أي خطأ، ولكن `boot_magic` قيمتها `0x00000000` بدل `0x00C0FFEE`. فالمتغير موجود في مكانه في الذاكرة، ولكن لا أحد وضع فيه قيمته الأولى، وفي المحاكي تبدأ الذاكرة بأصفار فظهر صفر، أما في الشريحة الحقيقية فتبدأ بقيم عشوائية، فقد ترى قيمة مختلفة في كل مرة تشغل فيها الجهاز. وتخيل أن هذا المتغير لم يكن رقماً للاختبار، وإنما الحد الأعلى لدرجة الحرارة المسموحة في الشحنة `int16_t max_temp_c10 = 80;`، فالجهاز يعمل ويسجل ويرسل، ولكنه يعتبر كل درجة حرارة فوق الصفر خارج المدى. وهذا النوع من الأخطاء لا يكتشفه المترجم ولا الرابط، ويكتشفه اختبار يطبع القيمة الأولى لمتغير معروف بعد الإقلاع كما فعلنا هنا، وهذا اختبار صغير يستحق أن يبقى في كل مشروع.

### مستوى التحسين Optimization: أثره على الحجم

وآخر خطوة في المختبر ترجمة نفس الكود بثلاثة مستويات تحسين ومقارنة الحجم:

```text
    972	      4	      8	    984	    3d8	size-O0.elf
    664	      4	      8	    676	    2a4	size-Os.elf
    980	      4	      8	    992	    3e0	size-O2.elf
```

والنتيجة قد تفاجئك، فالمستوى `-O2` الذي يهدف إلى السرعة أكبر قليلاً من `-O0` الذي لا يحسن شيئاً، 980 مقابل 972 بايت، والسبب أن `-O2` يدمج الدوال الصغيرة داخل من يستدعيها Inlining، فيتكرر كود `uart_putc` في عدة أماكن، وهذا أسرع لأنه لا يوجد استدعاء ولا رجوع، ولكنه أكبر. أما `-Os` فهدفه الحجم، وقد أعطى 664 بايت، أي أقل بالثلث تقريباً، وهو الاختيار المعتاد في الأجهزة التي يكون الفلاش فيها هو القيد، والفرق في السرعة بينه وبين `-O2` غالباً صغير لأن أغلب وقت الجهاز في الانتظار وليس في الحساب، ووصف كل مستوى في [خيارات التحسين في GCC](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html?ref=arabroot.io). وفي برنامج بهذا الحجم الفرق لا يهم، ولكن في جهاز حقيقي بشريحة فلاشها 64 KB وفيه مكتبة اتصال لاسلكي وبروتوكول تشفير، قد يكون هذا الثلث هو الفرق بين أن يتسع البرنامج أو لا يتسع، أو بين أن يبقى مكان لنسختين من البرنامج من أجل التحديث عن بعد OTA أو لا يبقى.

![أعمدة لحجم text: O0 بقيمة 972 بايت، وO2 بقيمة 980، وOs بقيمة 664، وO2 بدون volatile بقيمة 580، مع شرح أن O2 يدمج الدوال الصغيرة فيكبر، وأن Os مناسب عندما يكون الفلاش هو القيد، وأن أصغر نسخة كانت البرنامج الخاطئ](https://arabroot.io/content/images/2026/11/embedded-c-07-sizes-1.webp)

نفس الكود بأربعة أشكال، والقيمة هي القسم text من مخرج arm-none-eabi-size

ولاحظ أن أصغر رقم في الجدول كله هو 580، وهو البرنامج الخاطئ بدون `volatile`، وهذا تذكير بأن الحجم ليس مقياساً للصحة. وعندما ترى في مراجعة الكود أن حجم البرنامج نقص فجأة بنسبة كبيرة بعد تعديل صغير، فاسأل ما الذي حذفه المترجم ولماذا، قبل أن تفرح بالمساحة.

## من المحاكي Emulator إلى اللوحة الحقيقية

الملف `blink.elf` الذي شغلناه في Renode هو نفس الملف الذي يكتب في الشريحة الحقيقية بدون أي تعديل، والفرق في طريقة الوصول إليها. فلوحة STM32F4 Discovery عليها في الجزء العلوي شريحة ثانية تعمل كمبرمج ومصحح اسمه ST-LINK، تتصل بجهازك عبر USB، وتتصل بالشريحة الرئيسية عبر واجهة التصحيح SWD، وهي واجهة من سلكين تكتب في الفلاش وتوقف المعالج وتقرأ الذاكرة. وتكتب البرنامج بأداة مفتوحة المصدر مثل [OpenOCD](https://openocd.org/?ref=arabroot.io) أو [stlink](https://github.com/stlink-org/stlink?ref=arabroot.io)، فالأمر مع OpenOCD مثلاً هو `openocd -f board/stm32f4discovery.cfg -c "program blink.elf verify reset exit"`، ويقرأ الأداة العناوين من ملف ELF فتكتب كل قسم في مكانه. والمنفذ التسلسلي تراه على جهازك عبر محول USB إلى UART موصول بالرجل PA2، وبرنامج مثل `picocom` بسرعة 115200.

![صورة للوحة STM32F4 Discovery الخضراء وعليها الشريحة الرئيسية في الوسط وشريحة المبرمج ST-LINK في الأعلى بجانب منفذ USB، وأزرار وأضواء صغيرة](https://arabroot.io/content/images/2026/11/embedded-c-08-stm32f4-discovery-1.webp)

لوحة STM32F4 Discovery التي يحاكيها Renode في المختبر، وفي أعلاها المبرمج ST-LINK. الصورة: 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%289067299045%29.jpg?ref=arabroot.io) (تم تحويلها إلى WebP).

وهناك أشياء يجب أن تعرفها عن الفرق بين المحاكي والشريحة، لكي تعرف حدود ما يثبته المختبر. فالمحاكي يطابق ما يفعله البرنامج بالمسجلات، ويعطيك توقيتاً افتراضياً صحيحاً بالنسبة للساعة التي تضبطها، ولكنه لا يحاكي كل شيء: فلا يحاكي التأخير الحقيقي في قراءة الفلاش Wait States عند الترددات العالية، ولا الضوضاء الكهربائية، ولا سلوك الأرجل عند جهد غير مستقر، وقد يكون أكثر تسامحاً من الشريحة في بعض الأمور. ولذلك تستخدم الفرق المحاكي لكل ما هو منطق ومسجلات وتوقيت برمجي، في كل تعديل وفي كل CI، ثم تختبر على لوحات حقيقية ما يمس الكهرباء والتوقيت الدقيق قبل الإصدار. وفي مقال التصحيح في هذه المرحلة بإذن الله سوف نصل GDB بالمحاكي، ونتعلم كيف نوقف البرنامج على سطر ونراقب متغيراً، ونقرأ مسجلات الخطأ بعد HardFault.

ولكي ترى هذا التسامح بنفسك، بنينا نسخة رابعة بالخيار `-DNO_RCC` تحذف السطرين اللذين يشغلان ساعات المنافذ والمنفذ التسلسلي، وهو الخطأ الأول في قائمة الأخطاء الشائعة:

```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-c lab: STM32F407 bare metal
boot_magic=0x00C0FFEE toggles=0
t=500ms led=on toggles=1
t=1000ms led=off toggles=2
```

والنتيجة مطابقة للنسخة الصحيحة تماماً، فالضوء تغير مرتين والنص طبع كاملاً، والسبب أن نموذج المنافذ في Renode لا يربط عمل الطرفية بالبت الخاص بها في RCC، أما الشريحة الحقيقية فلن تضيء الضوء ولن تخرج حرفاً واحداً من هذه النسخة. وهذا لا يقلل من قيمة المحاكي، ولكنه يعني أن الأخطاء التي تمس الساعات وإعداد العتاد تحتاج اختباراً على لوحة، أو اختباراً في المحاكي يقرأ قيمة المسجل `RCC_AHB1ENR` بعد الإقلاع ويتحقق منها، وهذا سهل في Renode بأمر مثل `sysbus ReadDoubleWord 0x40023830`، وسوف نستخدم هذا النوع من الاختبارات في مقال التصحيح.

## كيف يبدو هذا في فريق حقيقي؟ HAL أم المسجلات Registers

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

| المستوى                   | مثال                                              | نقاط القوة                                          | نقاط الضعف                                                     |
| ------------------------- | ------------------------------------------------- | --------------------------------------------------- | -------------------------------------------------------------- |
| المسجلات مباشرة عبر CMSIS | GPIOD->BSRR = GPIO\_BSRR\_BS12;                   | أصغر حجم وأسرع كود، وترى كل ما يحدث                 | تقرأ الدليل لكل طرفية، والكود لا ينتقل لشريحة أخرى بسهولة      |
| طبقة منخفضة LL من ST      | LL\_GPIO\_SetOutputPin(GPIOD, LL\_GPIO\_PIN\_12); | أسماء واضحة ودوال صغيرة تدمج غالباً في المكان       | ما زالت قريبة من المسجلات، وخاصة بشرائح ST                     |
| طبقة تجريد العتاد HAL     | HAL\_GPIO\_TogglePin(GPIOD, GPIO\_PIN\_12);       | أسرع في الكتابة، ومولد كود جاهز من أداة STM32CubeMX | أكبر حجماً، وتخفي التوقيت، وتحتاج أن تقرأ كودها عندما يحدث خطأ |

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

والأشياء التي يضيفها الفريق الحقيقي حول هذا الكود، والتي ستجدها في أي مستودع جاد:

- **ميزانية الحجم Size Budget في CI**: خطوة تشغل `arm-none-eabi-size` بعد كل بناء، وتفشل إذا زاد الحجم عن حد متفق عليه أو زاد بنسبة كبيرة في تعديل واحد، لكي لا يكتشف الفريق امتلاء الفلاش قبل الإصدار بيوم.
- **التحذيرات كأخطاء**: `-Wall -Wextra -Werror` مع `-Wconversion` غالباً، لأن تحويل الأنواع الضمني بين 8 و16 و32 بت من أكثر مصادر الأخطاء في الكود الذي يتعامل مع الحساسات، وقد شرحنا أدوات الفحص في مقال [الأخطاء الشائعة في C وكشفها](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%81%D9%8A-c-%D9%88%D9%83%D8%B4%D9%81%D9%87%D8%A7-%D8%A8%D8%A7%D9%84%D8%A7%D8%AF%D9%88%D8%A7%D8%AA-sanitizers/).
- **قواعد كتابة مكتوبة** مثل MISRA C أو قواعد CERT C، وأداة فحص ثابت Static Analysis تطبقها في كل طلب دمج.
- **محاكاة في CI**: نفس ما فعلناه بـ Renode، ولكن مع اختبارات آلية تتحقق من مخرج المنفذ التسلسلي، وسوف نكتب هذه الاختبارات في مقال التصحيح.
- **ملف ربط وكود بداية تحت المراجعة**: هذه الملفات قليلاً ما تتغير، ولذلك قليلاً ما يفهمها أحد في الفريق، والتعديل فيها يحتاج مراجعة من شخص يفهم الأقسام والعناوين، لأن الخطأ فيها كما رأيت لا يعطي أي رسالة.

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

- نسيان تشغيل ساعة الطرفية في RCC، ثم الكتابة في مسجلاتها بدون أي أثر وبدون أي خطأ.
- كتابة المسجل كاملاً بالعلامة `=` بدل تعديل البتات المطلوبة، فتتغير أرجل أو إعدادات لا علاقة لها بما تعدله.
- متغير تشاركه المقاطعة مع الكود الرئيسي بدون `volatile`: يعمل بـ `-O0` ويتجمد بـ `-O2`، كما رأينا بالحلقة `b.n 800015a`.
- الظن أن `volatile` تجعل `count++` آمنة بين مقاطعتين، وهي لا تجعلها ذرية.
- القراءة والتعديل والكتابة على مسجل تكتب فيه المقاطعة أيضاً، بدل مسجل الضبط والمسح مثل `BSRR`.
- افتراض تردد ساعة غير الذي يعمل به الجهاز فعلاً، في الكود أو في المحاكي، فتصبح كل التوقيتات وسرعة المنفذ التسلسلي خاطئة.
- كود بداية لا ينسخ `.data` أو لا يصفر `.bss`، أو أسماء رموز في كود البداية لا تطابق ملف الربط.
- عنوان في جدول المقاطعات بدون البت الأخير 1، أو جدول ليس في أول الفلاش لأن ملف الربط لم يضعه أولاً أو حذفه `--gc-sections` لغياب `KEEP`.
- الاعتماد على `size` لمعرفة الذاكرة، ونسيان أن المكدس لا يظهر فيه، ثم امتلاء المكدس فوق المتغيرات بدون أي إنذار.
- جداول ثابتة كبيرة بدون `const`، فتأخذ مكاناً في الذاكرة إضافة إلى الفلاش.
- مقارنة الوقت بالطريقة `ticks < start + ms` بدل الطرح بدون إشارة، فيتعطل التأخير عندما يعود العداد إلى الصفر بعد قرابة 49.7 يوماً.

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

- المترجم والإصدار مثبتان في Docker Image أو ملف إعداد، لكي يبني الجميع نفس الملف.
- ملف الربط يطابق الشريحة الدقيقة: حجم الفلاش والذاكرة صحيحان، و`KEEP` حول جدول المقاطعات.
- كود البداية ينسخ `.data` ويصفر `.bss`، واختبار بعد الإقلاع يطبع قيمة متغير معروف.
- تردد الساعة معرف في مكان واحد، وكل القيم المشتقة منه محسوبة في الكود لا مكتوبة باليد.
- كل مسجل وكل متغير تشاركه مقاطعة معرف بـ `volatile`، والعمليات المشتركة بين مقاطعة وكود محمية.
- الخيارات `-ffunction-sections -fdata-sections -Wl,--gc-sections` وملف خريطة يولد مع كل بناء.
- خطوة في CI تطبع مخرج `size` وتفشل عند تجاوز الحد، وخطوة تشغل البرنامج في محاكي بنفس الساعة.
- حجم المكدس مقدر بـ `-fstack-usage` وله هامش واضح في ملف الربط.
- مستوى التحسين في نسخة الاختبار هو نفسه في نسخة الإنتاج، لكي لا يظهر خطأ `volatile` لأول مرة عند العميل.

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

- غير قلب الضوء من `GPIOD_ODR ^=` إلى الكتابة في `BSRR` عند `0x40020C18`، بحيث تكتب البت 12 للإضاءة والبت 28 للإطفاء، ثم تحقق في سجل Renode أن الضوء ما زال يتغير مرتين في 1.2 ثانية.
- أضف الثلاثة أضواء الأخرى على PD13 وPD14 وPD15، واجعلها تضيء بالتتابع، ثم انظر في ملف `stm32f4_discovery-additional_gpios.repl` داخل Renode لتعرف كيف تسجل تغيراتها.
- أضف جدولاً ثابتاً من 256 عنصراً من نوع `uint16_t` مرة مع `const` ومرة بدونها، وقارن مخرج `size` في الحالتين وفسر الفرق.
- ترجم بالخيار `-fstack-usage` واقرأ ملفات `.su` الناتجة، وأي دالة تحتاج أكبر مكدس.

## الخلاصة Summary

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

- البرنامج المدمج يعمل غالباً بدون نظام تشغيل، فكل ما كان يفعله النظام لك، من تجهيز الذاكرة إلى استدعاء `main`، صار مسؤولية كود البداية وملف الربط.
- كل شيء في المتحكم له عنوان في مساحة واحدة: الفلاش عند `0x08000000` والذاكرة عند `0x20000000` والطرفيات عند `0x40000000`، والمسجل خانة 32 بت تكتب فيها فيتغير العتاد.
- الوصول إلى طرفية يحتاج ساعتها أولاً، ثم إعدادها، ثم استخدامها، وتعديل البتات المطلوبة فقط، وتجنب القراءة والتعديل والكتابة على مسجل تشاركه مقاطعة.
- `volatile` تجبر المترجم على القراءة والكتابة في كل مرة، وبدونها حول GCC 14.2 حلقة التأخير إلى `b.n 800015a` وحذف 400 بايت من البرنامج، ولكنها لا تعطي ذرية ولا حواجز ذاكرة.
- المعالج يقرأ مؤشر المكدس وعنوان `Reset_Handler` من أول كلمتين في الفلاش، وكود البداية ينسخ `.data` من عنوان التحميل إلى عنوان التشغيل ويصفر `.bss`، وبدون النسخ طبع البرنامج `boot_magic=0x00000000` بلا أي خطأ.
- مخرج `size` وملف الخريطة يقولان لك أين ذهب كل بايت: 980 بايت كود و4 بيانات و8 أصفار، والمكدس لا يظهر فيهما.
- كل توقيت مشتق من ساعة، والمحاكي بساعة 72 MHz جعل برنامجنا أسرع 4.5 مرة حتى ضبطناه على 16 MHz كالشريحة بعد التشغيل.
- Renode يشغل نفس ملف ELF الذي يكتب في الشريحة، ويعطيك وقتاً افتراضياً وسجلاً للأرجل وتشغيلاً في CI، واللوحة الحقيقية تبقى لما يمس الكهرباء والتوقيت الدقيق.

وفي [المقال القادم](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](https://arabroot.io/start/#stage-elec-firmware) بإذن الله سوف نرى ماذا يحدث عندما يكبر مسجل الحرارة ويصبح فيه حساس وذاكرة واتصال لاسلكي، وتصبح حلقة `for` الواحدة غير كافية، فننتقل إلى أنظمة التشغيل الفورية RTOS. وإلى ذلك الحين، هذه المقالات تكمل ما بنينا عليه هنا:

[![](https://arabroot.io/content/images/2026/11/rtos-freertos-zephyr-cover-cover-1.webp)دليلأنظمة التشغيل الفورية RTOS مع FreeRTOS ثم Zephyrنشرح المهام والمجدول والطوابير والأقفال في الأنظمة الفورية، ثم نعيد مشكلة انعكاس الأولوية التي أوقفت Mars Pathfinder على FreeRTOS ثم Zephyr في QEMU، ونقيسها قبل الإصلاح وبعده.](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/)[![](https://arabroot.io/content/images/2026/10/c-for-devs-cover-cover.webp)دليللغة C لمن يبرمج بلغة أخرى: المترجم GCC والأدواتنبني مكتبة صغيرة تحسب ضريبة الفاتورة بالهللات بأحدث GCC، ونمر على ما يختلف في C عما تعرفه، ومراحل الترجمة، والتحذيرات، وCMake، وأدوات التنسيق والفحص والاختبار والتصحيح.](https://arabroot.io/articles/%D9%84%D8%BA%D8%A9-c-%D9%84%D9%85%D9%86-%D9%8A%D8%A8%D8%B1%D9%85%D8%AC-%D8%A8%D9%84%D8%BA%D8%A9-%D8%A7%D8%AE%D8%B1%D9%89-%D8%A7%D9%84%D9%85%D8%AA%D8%B1%D8%AC%D9%85-gcc-%D9%88%D8%A7%D9%84%D8%A7%D8%AF%D9%88%D8%A7%D8%AA/)[![](https://arabroot.io/content/images/2026/10/c-types-memory-cover-cover.webp)دليلالمؤشرات Pointers والذاكرة والأخطاء في لغة Cنقرأ ملف طلبات نقطة البيع بلغة C ونقف عند كل ما تسمح به اللغة دون أن تخبرك: تحويلات الأنواع، والحشو، وتجاوز المخزن، ومن يحرر الذاكرة، وكيف تصل الأخطاء بقيمة الرجوع وerrno.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D8%A4%D8%B4%D8%B1%D8%A7%D8%AA-pointers-%D9%88%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D8%A7%D8%AE%D8%B7%D8%A7%D8%A1-%D9%81%D9%8A-%D9%84%D8%BA%D8%A9-c/)[![](https://arabroot.io/content/images/2026/10/c-idioms-cover-cover.webp)دليلأخطاء شائعة في C وكشفها بالأدوات Sanitizersأربعة عشر خطأً يقع فيها من يأتي إلى C من لغة أخرى، شغلنا كلاً منها ورأينا أي أداة كشفته وأيها فاتها، ثم جربنا التغذية العشوائية على قارئ الطلبات، وختمنا بخطة قراءة من المصادر الرسمية.](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%81%D9%8A-c-%D9%88%D9%83%D8%B4%D9%81%D9%87%D8%A7-%D8%A8%D8%A7%D9%84%D8%A7%D8%AF%D9%88%D8%A7%D8%AA-sanitizers/)[![](https://arabroot.io/content/images/2026/10/cpu-internals-cover-cover.webp)دليلكيف يعمل المعالج CPU من الداخل ولماذا يهمك ذلكنتابع تعليمة واحدة داخل نواة المعالج، ونرى لماذا يصبح نفس الكود أبطأ بعشر مرات عندما تغير ترتيب المرور على البيانات.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)[![](https://arabroot.io/content/images/2026/10/memory-basics-cover-cover.webp)دليلالذاكرة للمبرمجين: كيف تعمل ال Stack وال Heapلماذا تتغير قائمة لم تطلب تغييرها، وكيف تتسرب الذاكرة في لغة فيها جامع قمامة Garbage Collector، بأمثلة حقيقية من عدة لغات.](https://arabroot.io/articles/%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-%D9%84%D9%84%D9%85%D8%A8%D8%B1%D9%85%D8%AC%D9%8A%D9%86-stack-%D9%88-heap-%D9%88%D8%A7%D9%84%D9%85%D8%A4%D8%B4%D8%B1%D8%A7%D8%AA/)[![](https://arabroot.io/content/images/2026/10/compiler-pipeline-cover-cover.webp)دليلداخل المترجم Compiler: من الكود إلى IR وكود الآلةنفتح GCC وClang على ملف C صغير ونقرأ كل مرحلة يمر بها، من الشجرة إلى SSA والتحسينات وكود الآلة، ونرى كيف حذف المترجم فحصاً بسبب سلوك غير معرف.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%AA%D8%B1%D8%AC%D9%85-%D9%85%D9%86-%D8%A7%D9%84%D9%83%D9%88%D8%AF-%D8%A7%D9%84%D9%89-ir-%D9%88%D8%A7%D9%84%D8%AA%D8%AD%D8%B3%D9%8A%D9%86%D8%A7%D8%AA-%D9%88%D9%83%D9%88%D8%AF-%D8%A7%D9%84%D8%A7%D9%84%D8%A9/)

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

- نوفمبر 2026: كتابة المقال، وبناء البرنامج وتشغيل كل الأوامر داخل Container من Docker Image مبنية على debian:trixie-20261104-slim، مع arm-none-eabi-gcc 14.2.rel1 (GCC 14.2.1) وGNU binutils من Debian 13، والمحاكي Renode 1.17.0 بوصف اللوحة stm32f4\_discovery-kit، على Docker Engine 29.8.0.