تُعَد شيفرة نظام التشغيل البرمجية للقراءة فقط وتكون منفصلة عن البيانات، لذا إن لم تتمكن البرامج من تعديل الشيفرة البرمجية مع وجود كميات كبيرة من الشيفرة البرمجية المشتركة أمرًا منطقيًا، إذ يجب مشاركتها بين العديد من الملفات القابلة للتنفيذ بدلًا من تكرارها لكل ملف منها.

يمكن تطبيق ذلك بسهولة باستخدام الذاكرة الوهمية، إذ يمكن الرجوع بسهولة إلى صفحات الذاكرة الحقيقية التي جرى تحميل شيفرة المكتبة البرمجية إليها من خلال عدد من الصفحات الوهمية في عددٍ من فضاءات العناوين. لذا يمكن لكل عملية الوصول إلى شيفرة المكتبة البرمجية باستخدام أيّ عنوان وهمي تريده، بينما يكون لديك نسخة حقيقية واحدة فقط من هذه الشيفرة في ذاكرة النظام.

وبذلك توصل المبرمجون بسرعة إلى فكرة المكتبة المشتركة Shared Library التي -كما يوحي الاسم- يمكن مشاركتها بين العديد من الملفات القابلة للتنفيذ. يحتوي كل ملف قابل للتنفيذ على مرجع يقول: "أحتاج مكتبة Foo مثلًا"، حيث يُترَك الأمر للنظام عند تحميل البرنامج للتحقق من وجود برنامج آخر حمّل شيفرة هذه المكتبة في الذاكرة ثم مشاركتها من خلال ربط صفحات الملف القابل للتنفيذ مع الذاكرة الحقيقية، أو يمكنه تحميل المكتبة في ذاكرة الملف القابل للتنفيذ. تسمى هذه العملية بالربط الديناميكي Dynamic Linking، لأنها تطبّق جزءًا من عملية الربط مباشرةً عند تنفيذ البرامج في النظام.

تفاصيل المكتبة الديناميكية

تشبه المكتبات إلى حدٍ كبير برنامجًا لا يُشغَّل أبدًا، إذ لديها قسم الشيفرة البرمجية وقسم البيانات (الدوال والمتغيرات) تمامًا مثل الملفات القابل للتنفيذ، ولكن لا يمكن تشغيلها، فهي توفر فقط مكتبة من الدوال للمطورين لاستدعائها. لذا يمكن ملف ELF أن يمثل مكتبة ديناميكية تمامًا كما يمثل ملفًا قابلًا للتنفيذ مع وجود بعض الاختلافات الأساسية مثل عدم وجود مؤشر للمكان الذي يجب أن يبدأ فيه التنفيذ، ولكن تُعَد جميع المكتبات المشتركة مجرد كائنات بصيغة ELF مثل أي ملف آخر قابل للتنفيذ.

تحتوي ترويسة ملف ELF على رايتين حصريتين هما ET_EXEC وET_DYN لتمييز ملف ELF بوصفه ملفًا قابلًا للتنفيذ أو ملفَ كائن مشترك.

تضمين المكتبات في ملف قابل للتنفيذ

يمكن تضمين المكتبات في ملف قابل للتنفيذ ولكن يجب أن نراعي مسألتين مهمتين متعلقتين بالمصرِّف والرابط الديناميكي كما سنوضح الآن.

التصريف Compilation

تمتلك ملفات الكائنات مراجعًا إلى دوال المكتبة تمامًا كما هو الحال مع أيّ مرجع خارجي آخر عندما تصرِّف برنامجك الذي يستخدم مكتبة ديناميكية. يجب تضمين ترويسة المكتبة ليعرف المصرِّف الأنواع المحددة للدوال التي تستدعيها، إذ يحتاج المصرِّف فقط معرفةَ الأنواع المرتبطة بالدالة (مثل أن تأخذ الدالة النوع int وتعيد النوع char *‎) بحيث يمكنه تخصيص مساحة لاستدعاء الدالة بصورة صحيحة.

لم يكن هذا هو الحال دائمًا مع معايير لغة C، إذ افترضت المصِّرفات سابقًا أن أيّ دالة غير معروفة تعيد قيمة من النوع int. يكون لحجم المؤشر في نظام 32 بت حجم النوع int نفسه، لذلك لا توجد مشكلة في ذلك، ولكن يكون حجم المؤشر ضعف حجم int في نظام 64 بت، لذلك إذا أعادت الدالة مؤشرًا، فستُدمَّر قيمتها. يُعَد ذلك الأمر غير مقبول، لأن المؤشر لن يؤشّر إلى ذاكرة صالحة، ولكن تغيّر معيار C99 بحيث يُطلَب منك تحديد أنواع الدوال المُضمَّنة.

الربط Linking

يطبّق الرابط الديناميكي الكثير من العمل للمكتبات المشتركة، ولكن لا يزال الرابط التقليدي يلعب دورًا هامًا في إنشاء الملف القابل للتنفيذ، إذ يجب أن يضع الرابط التقليدي مؤشرًا في الملف القابل للتنفيذ حتى يعرف الرابط الديناميكي المكتبة التي ستحقّق الاعتماديات Dependencies في وقت التشغيل. يتطلب القسم dynamic من الملف القابل للتنفيذ مدخلة مطلوبة NEEDED لكل مكتبة مشتركة يعتمد عليها الملف القابل للتنفيذ.

يمكننا فحص هذه الحقول باستخدام برنامج readelf. سنلقي فيما يلي نظرة على ملف ثنائي معياري ‎/bin/ls يمثل تحديد المكتبات الديناميكية:

$ readelf --dynamic /bin/ls 

Dynamic segment at offset 0x22f78 contains 27 entries:
  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [librt.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libacl.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6.1]
 0x000000000000000c (INIT)               0x4000000000001e30
 ... snip ...

يمكنك أن ترى أن المثال السابق يحدد ثلاث مكتبات. المكتبة الأكثر شيوعًا التي تتشارك بها أغلبية البرامج الموجودة على النظام -إن لم تكن جميعها- هي مكتبة libc، وهناك بعض المكتبات الأخرى التي يحتاجها البرنامج ليعمل بصورة صحيحة.

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

$ ldd /bin/ls
        librt.so.1 => /lib/tls/librt.so.1 (0x2000000000058000)
        libacl.so.1 => /lib/libacl.so.1 (0x2000000000078000)
        libc.so.6.1 => /lib/tls/libc.so.6.1 (0x2000000000098000)
        libpthread.so.0 => /lib/tls/libpthread.so.0 (0x20000000002e0000)
        /lib/ld-linux-ia64.so.2 => /lib/ld-linux-ia64.so.2 (0x2000000000000000)
        libattr.so.1 => /lib/libattr.so.1 (0x2000000000310000)
$ readelf --dynamic /lib/librt.so.1

Dynamic segment at offset 0xd600 contains 30 entries:
  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6.1]
 0x0000000000000001 (NEEDED)             Shared library: [libpthread.so.0]
 ... snip ...

يمكننا أن نرى في المثال السابق أن مكتبة libpthread مطلوبة من مكان ما، حيث إذا تعمّقنا قليلًا، فيمكننا أن نرى أنها مطلوبة من المكتبة librt.

الرابط الديناميكي Dynamic Linker

الرابط الديناميكي هو البرنامج الذي يدير المكتبات الديناميكية المشتركة بدلًا من الملف القابل للتنفيذ، ويعمل على تحميل المكتبات في الذاكرة وتعديل البرنامج في وقت التشغيل لاستدعاء الدوال الموجودة في المكتبة. يسمح ملف ELF للملفات القابلة للتنفيذ بتحديد المفسّر Interpreter الذي هو برنامج يجب استخدامه لتشغيل الملف القابل للتنفيذ. يضبط المصرِّف Compiler والرابط الساكن Static Linker مفسّر الملفات القابلة للتنفيذ الذي يعتمد على المكتبات الديناميكية ليكون الرابط الديناميكي.

يوضَح المثال التالي كيفية التحقق من مفسّر البرنامج:

ianw@lime:~/programs/csbu$ readelf --headers /bin/ls

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x4000000000000040 0x4000000000000040
                 0x0000000000000188 0x0000000000000188  R E    8
  INTERP         0x00000000000001c8 0x40000000000001c8 0x40000000000001c8
                 0x0000000000000018 0x0000000000000018  R      1
      [Requesting program interpreter: /lib/ld-linux-ia64.so.2]
  LOAD           0x0000000000000000 0x4000000000000000 0x4000000000000000
                 0x0000000000022e40 0x0000000000022e40  R E    10000
  LOAD           0x0000000000022e40 0x6000000000002e40 0x6000000000002e40
                 0x0000000000001138 0x00000000000017b8  RW     10000
  DYNAMIC        0x0000000000022f78 0x6000000000002f78 0x6000000000002f78
                 0x0000000000000200 0x0000000000000200  RW     8
  NOTE           0x00000000000001e0 0x40000000000001e0 0x40000000000001e0
                 0x0000000000000020 0x0000000000000020  R      4
  IA_64_UNWIND   0x0000000000022018 0x4000000000022018 0x4000000000022018
                 0x0000000000000e28 0x0000000000000e28  R      8

يمكنك أن ترى في المثال السابق أن المفسّر مضبوط ليكون ‎/lib/ld-linux-ia64.so.2 أي يمثل الرابط الديناميكي. تتحقق النواة Kernel عندما تحمّل الملف الثنائي للتنفيذ مما إذا كان الحقل PT_INTERP موجودًا، حيث إذا كان موجودًا، فيجب تحميل ما يؤشّر إليه في الذاكرة وتشغيله.

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

الانتقالات Relocations

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

هناك العديد من أنواع الانتقالات لكل معمارية، حيث يُوثَّق السلوك الدقيق لكل نوع بوصفه جزءًا من واجهة ABI الخاصة بالنظام. يُعَد تعريف الانتقالات واضحًا وسهلًا كما في المثال التالي:

typedef struct {
  Elf32_Addr    r_offset;  <--- address to fix
  Elf32_Word    r_info;    <--- symbol table pointer and relocation type
}

typedef struct {
  Elf32_Addr    r_offset;
  Elf32_Word    r_info;
  Elf32_Sword   r_addend;
} Elf32_Rela

يشير الحقل r_offset إلى الإزاحة في الملف التي يجب إصلاحها، ويحدد الحقل r_info نوع الانتقال الذي يصِف بالضبط ما يجب تطبيقه لإصلاح هذه الشيفرة البرمجية. تُعَد قيمة الرمز أبسط عملية انتقال مُعرَّفة لمعماريةٍ ما، حيث يمكنك ببساطة في هذه الحالة استبدال عنوان الرمز في الموقع المحدد، وبالتالي سيكتمل إصلاح عملية الانتقال.

يوجد نوعان من الطرق المُستخدمة لتشغيل الانتقالات أحدهما مع قيمة مُضافة والآخر بدونها. القيمة المضافة هي ببساطة شيء يجب إضافته إلى العنوان الذي جرى إصلاحه للعثور على العنوان الصحيح، فمثلًا إذا كان الانتقال للرمز i مثلًا، فستُضبَط القيمة المُضافة على القيمة 8 لأن الشيفرة البرمجية الأصلية تطبّق شيئًا مثل i[8]‎، وهذا يعني العثور على عنوان i ثم تجاوزه بمقدار 8.

يجب تخزين هذه القيمة المضافة في مكان ما، فمثلًا تُخزَّن في صيغة REL القيمة المُضافة في شيفرة البرنامج ضمن المكان الذي يجب أن يكون فيه العنوان الذي جرى إصلاحه. لذا يجب إصلاح العنوان بصورة صحيحة من خلال قراءة الذاكرة التي تريد إصلاحها للحصول على أيّ قيمة مضافة وتخزينها والعثور على العنوان الحقيقي وإضافة القيمة المضافة إليه ثم كتابته مرة أخرى فوق القيمة المضافة. بينما تحدد الصيغة RELA مكان القيمة المضافة في الانتقال مباشرةً.

هناك بعض المقايضات لكلٍ من هاتين الصيغتين، إذ يجب في صيغة REL استخدام مرجع ذاكرة إضافي للعثور على القيمة المضافة قبل الإصلاح، لكنك لا تهدر مساحةً في الملف الثنائي لأنك تستخدم الذاكرة الهدف لعملية الانتقال. بينما يمكنك في صيغة RELA الاحتفاظ بالقيمة المضافة مع الانتقال، ولكنك تهدر هذه المساحة في ملف القرص الصلب الثنائي. تستخدم معظم الأنظمة الحديثة انتقالات RELA.

كيفية عمل الانتقالات

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

$ cat addendtest.c
extern int i[4];
int *j = i + 2;

$ cat addendtest2.c
int i[4];

$ gcc -nostdlib -shared -fpic -s -o addendtest2.so addendtest2.c
$ gcc -nostdlib -shared -fpic -o addendtest.so addendtest.c ./addendtest2.so

$ readelf -r ./addendtest.so

Relocation section '.rela.dyn' at offset 0x3b8 contains 1 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
0000000104f8  000f00000027 R_IA64_DIR64LSB   0000000000000000 i + 8

لدينا عملية انتقال واحدة في addendtest.so من النوع R_IA64_DIR64LSB الذي إن بحثت عنه في واجهة IA64 ABI، فيمكن تقسيمه إلى ما يلي:

1. R_IA64: تبدأ جميع الانتقالات بهذه البادئة.
2. DIR64: انتقال من النوع 64 بت المباشر.
3. LSB: بما أن IA64 يمكن أن تعمل في أنماط Big Endian على تخزين البتات الأقل أهمية أولًا، و في أنماط Little Endian على تخزين البتات الأكثر أهمية أولًا، فسيكون هذا الانتقال Little Endian والذي يعني البايت الأقل أهميةً Least Significant Byte.

تقول واجهة ABI أن هذا الانتقال يمثل قيمة الرمز الذي يؤشّر إليه مع أيّ قيمة مضافة. يمكننا أن نرى أن لدينا قيمة مضافة مقدارها 8 ، حيث أن حجم النوع int يساوي 4 أو sizeof(int) == 4، ونقلنا قيمتين من النوع int في المصفوفة أي ‎*j = i + 2. لذا يمكن إصلاح هذا الانتقال في وقت التشغيل من خلال العثور على عنوان الرمز i ووضع قيمته بالإضافة إلى القيمة 8 في 0x104f8.

استقلال المواقع

يُعطَى مقطع الشيفرة البرمجية ومقطع البيانات في ملف قابل للتنفيذ عنوانًا أساسيًا محددًا في الذاكرة الوهمية، لذا لا يمكن مشاركة شيفرة الملف القابل للتنفيذ الذي يحصل على فضاء عناوين جديد خاص به، وهذا يعني أن المصرِّف يعرف بالضبط مكان قسم البيانات ويمكنه الرجوع إليه مباشرةً.

لا تمتلك المكتبات مثل هذا الضمان، إذ يمكنها معرفة أن قسم البيانات الخاص بها سيكون إزاحة محددة عن العنوان الأساسي، ولكن لا يمكن بالضبط معرفة مكان ذلك العنوان الأساسي إلّا في وقت التشغيل. لذا يجب إنشاء جميع المكتبات باستخدام شيفرة برمجية يمكن تنفيذها بغض النظر عن مكان وضعها في الذاكرة، ويُعرَف ذلك باسم الشيفرة المستقلة عن الموقع Position Independent Code، أو PIC اختصارًا. لاحظ أن قسم البيانات لا يزال يمثل إزاحة ثابتة عن قسم الشيفرة البرمجية، ولكن يجب إضافة الإزاحة إلى عنوان التحميل للعثور على عنوان البيانات.

جدول الإزاحة العام Global Offset Table

لا بد أنك لاحظت مشكلة خطيرة في الانتقالات Relocations عند التفكير في أهداف المكتبة المشتركة، حيث ذكرنا سابقًا أن ميزة المكتبة المشتركة مع الذاكرة الوهمية هي أن البرامج المتعددة يمكنها استخدام الشيفرة البرمجية الموجودة في الذاكرة من خلال مشاركة الصفحات.

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

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

المنطقة المخصصة لهذه العناوين تسمى بجدول الإزاحة العام Global Offset Table -أو GOT اختصارًا- الذي يتواجد في القسم ‎.got من ملف ELF.

يوضح الشكل التالي كيفية الوصول إلى الذاكرة باستخدام جدول GOT:

يُعَد جدول GOT خاصًا بكل عملية، ويجب أن يكون للعملية أذونات للكتابة خاصة بها. بينما يمكن مشاركة شيفرة المكتبة ويجب أن يكون للعملية فقط أذونات قراءة وتنفيذ الشيفرة البرمجية، وإلا فسيكون هناك خرق أمني خطير إذا تمكنت العملية من تعديل الشيفرة البرمجية.

كيفية عمل جدول GOT

يوضح المثال التالي كيفية استخدام جدول GOT:

$ cat got.c
extern int i;

void test(void)
{
  i = 100;
}

$ gcc -nostdlib  -shared -o got.so ./got.c

$ objdump --disassemble ./got.so

./got.so:     file format elf64-ia64-little

Disassembly of section .text:

0000000000000410 <test>:
 410:   0d 10 00 18 00 21       [MFI]       mov r2=r12
 416:   00 00 00 02 00 c0                   nop.f 0x0
 41c:   81 09 00 90                         addl r14=24,r1;;
 420:   0d 78 00 1c 18 10       [MFI]       ld8 r15=[r14]
 426:   00 00 00 02 00 c0                   nop.f 0x0
 42c:   41 06 00 90                         mov r14=100;;
 430:   11 00 38 1e 90 11       [MIB]       st4 [r15]=r14
 436:   c0 00 08 00 42 80                   mov r12=r2
 43c:   08 00 84 00                         br.ret.sptk.many b0;;

$ readelf --sections ./got.so
There are 17 section headers, starting at offset 0x640:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .hash             HASH             0000000000000120  00000120
       00000000000000a0  0000000000000004   A       2     0     8
  [ 2] .dynsym           DYNSYM           00000000000001c0  000001c0
       00000000000001f8  0000000000000018   A       3     e     8
  [ 3] .dynstr           STRTAB           00000000000003b8  000003b8
       000000000000003f  0000000000000000   A       0     0     1
  [ 4] .rela.dyn         RELA             00000000000003f8  000003f8
       0000000000000018  0000000000000018   A       2     0     8
  [ 5] .text             PROGBITS         0000000000000410  00000410
       0000000000000030  0000000000000000  AX       0     0     16
  [ 6] .IA_64.unwind_inf PROGBITS         0000000000000440  00000440
       0000000000000018  0000000000000000   A       0     0     8
  [ 7] .IA_64.unwind     IA_64_UNWIND     0000000000000458  00000458
       0000000000000018  0000000000000000  AL       5     5     8
  [ 8] .data             PROGBITS         0000000000010470  00000470
       0000000000000000  0000000000000000  WA       0     0     1
  [ 9] .dynamic          DYNAMIC          0000000000010470  00000470
       0000000000000100  0000000000000010  WA       3     0     8
  [10] .got              PROGBITS         0000000000010570  00000570
       0000000000000020  0000000000000000 WAp       0     0     8
  [11] .sbss             NOBITS           0000000000010590  00000590
       0000000000000000  0000000000000000   W       0     0     1
  [12] .bss              NOBITS           0000000000010590  00000590
       0000000000000000  0000000000000000  WA       0     0     1
  [13] .comment          PROGBITS         0000000000000000  00000590
       0000000000000026  0000000000000000           0     0     1
  [14] .shstrtab         STRTAB           0000000000000000  000005b6
       000000000000008a  0000000000000000           0     0     1
  [15] .symtab           SYMTAB           0000000000000000  00000a80
       0000000000000258  0000000000000018          16    12     8
  [16] .strtab           STRTAB           0000000000000000  00000cd8
       0000000000000045  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings)
  I (info), L (link order), G (group), x (unknown)
  O (extra OS processing required) o (OS specific), p (processor specific)

يوضّح المثال السابق كيفية إنشاء مكتبة مشتركة بسيطة تشير إلى رمز خارجي. لا نعرف عنوان هذا الرمز في وقت التصريف، لذلك نتركه للرابط الديناميكي لإصلاحه في وقت التشغيل. لكننا نريد أن تبقى الشيفرة البرمجية قابلةً للمشاركة في حالة رغبة العمليات الأخرى في استخدام هذه الشيفرة، حيث يوضّح التفكيك Disassembly كيفية تطبيق ذلك باستخدام القسم ‎.got. يُعرف المسجّل r1 في معمارية IA64 التي صُرِّفت المكتبة من أجلها بالمؤشر العام Global Pointer الذي يؤشّر دائمًا إلى مكان تحميل القسم ‎.got في الذاكرة.

إذا ألقينا نظرة على خرج الأداة readelf، فيمكننا أن نرى أن القسم ‎.got يبدأ عند عنوان يبعد بمقدار 0x10570 بايت عن مكان تحميل المكتبة في الذاكرة. لذا إذا حُمِّلت المكتبة في الذاكرة عند العنوان 0x6000000000000000، فسيكون القسم ‎.got موجودًا عند العنوان 0x6000000000010570، وسيؤشّر المسجّل r1 دائمًا إلى هذا العنوان.

كما يمكننا أن نرى أننا نخزن القيمة 100 في عنوان الذاكرة الموجود في المسجّل r15 الذي يحتوي على قيمة عنوان الذاكرة المخزن في المسجل 14، حيث حمّلنا هذا العنوان من خلال إضافة عدد صغير إلى المسجّل 1. يُعَد جدول GOT مجرد قائمة طويلة من المدخلات، حيث تكون كل مدخلة خاصةً بمتغير خارجي، مما يعني أن مدخلة جدول GOT الخاصة بالمتغير الخارجي i تخزّن 24 بايتًا أو 3 عناوين بحجم 64 بتًا.

$ readelf --relocs ./got.so

Relocation section '.rela.dyn' at offset 0x3f8 contains 1 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
000000010588  000f00000027 R_IA64_DIR64LSB   0000000000000000 i + 0

كما يمكننا التحقق من انتقال مدخلة جدول GOT، حيث يمثل الانتقالُ استبدالَ القيمة عند الإزاحة 10588 بموقع الذاكرة الذي خُزِّن فيه الرمز i.

يبدأ القسم ‎.got عند الإزاحة 0x10570 عن الخرج السابق، حيث رأينا كيف تحمّل الشيفرة البرمجية عنوانًا يبعد عن القسم ‎.got بمقدار 0x18 (أو 24 في النظام العشري)، مما يمنحنا عنوانًا مقداره 0x10570 + 0x18 = 0x10588 يمثّل العنوان الذي طُبِّق الانتقال لأجله. لذا يجب أن يصلح الرابط الديناميكي الانتقال قبل أن يبدأ البرنامج للتأكد من أن قيمة الذاكرة عند الإزاحة 0x10588 هي عنوان المتغير العام i.

ترجمة -وبتصرُّف- للأقسام Code Sharing و The Dynamic Linker و Global Offset Tables من فصل Dynamic Linking من كتاب Computer Science from the Bottom Up لصاحبه Ian Wienand.

اقرأ أيضًا

• المقال التالي: المكتبات وكيفية استدعاء دوالها ديناميكيًا في معمارية الحاسوب
• المقال السابق: مفاهيم متقدمة متعلقة بصيغة ملفات ELF القابلة للتنفيذ
• أنظمة المعالجات في معمارية الحاسوب
• العمليات وعناصرها في نظام تشغيل الحاسوب

ذكرنا سابقًا أن البرنامج لا يبدأ بالدالة الرئيسية main()‎، حيث سنختبر في هذا المقال ما يحدث لبرنامج مرتبط ديناميكيًا عند تحميله وتشغيله.

تخصّص النواة أولًا البنى لعملية جديدة وتقرأ ملف ELF المُحدَّد من القرص الصلب استجابةً لاستدعاء النظام exec. ذكرنا أن صيغة ELF لديها حقل لمفسّر Interpreter البرنامج هو PT_INTERP الذي يمكن ضبطه لتفسير البرنامج، حيث يكون المفسِّر بالنسبة للتطبيقات المرتبطة ديناميكيًا هو الرابط الديناميكي Dynamic Linker -أو ld.so- الذي يسمح بإجراء بعض عمليات الربط مباشرةً قبل بدء البرنامج.

كما تقرأ النواة شيفرة الرابط الديناميكي، وتبدأ البرنامج من عنوان نقطة الدخول entry point الذي تحدده. سنختبر دور الرابط الديناميكي بالتفصيل لاحقًا، ولكن يكفي أن نقول أنه يضبط بعض الإعدادات مثل تحميل المكتبات التي يتطلبها التطبيق كما هو محدد في القسم الديناميكي من الملف الثنائي، ثم يبدأ تنفيذ البرنامج الثنائي عند عنوان نقطة الدخول أي الدالة ‎_init.

اتصال النواة بالبرامج

تحتاج النواة Kernel إلى توصيل بعض الأشياء للبرامج عند بدء تشغيلها مثل وسائط البرنامج arguments ومتغيرات البيئة الحالية environment variables وبنية خاصة اسمها المتجه المساعد Auxiliary Vector أو auxv اختصارًا. يمكنك أن تطلب من الرابط الديناميكي أن يُظهر لك بعضًا من خرج تنقيح الأخطاء من البنية auxv من خلال تحديد قيمة البيئة كما يلي LD_SHOW_AUXV=1. تسمح الوسائط والبيئة والأشكال المختلفة من استدعاء النظام exec بتحديد هذه الأشياء للبرنامج التي يمكن للنواة توصيلها من خلال وضع جميع المعلومات المطلوبة في المكدس ليلتقطها البرنامج المُنشَأ حديثًا، وبالتالي يمكن للبرنامج عند بدء تشغيله استخدام مؤشر المكدس الخاص به للعثور على جميع معلومات بدء التشغيل المطلوبة.

المتجه المساعد هو بنية خاصة لنقل المعلومات مباشرةً من النواة إلى البرنامج المُشغَّل حديثًا، ويحتوي على معلومات خاصة بالنظام يمكن أن تكون مطلوبة مثل الحجم الافتراضي لصفحة الذاكرة الوهمية على النظام أو إمكانات العتاد، وهذه هي الميزات التي تحددها النواة للعتاد الأساسي ويمكن أن تستفيد منها برامج مساحة المستخدمين.

مكتبة النواة Kernel Library

ذكرنا سابقًا أن استدعاءات النظام بطيئة وأن الأنظمة الحديثة لديها آليات لتجنب الحِمل الناتج عن استدعاء مصيدة Trap للمعالج، حيث يمكن تنفيذ ذلك في نظام لينكس من خلال استخدام حيلة بين المحمل الديناميكي والنواة المتصلَين ببنية AUXV، إذ تضيف النواة مكتبة مشتركة صغيرة إلى فضاء العناوين لكل عملية مُنشَأة حديثًا وتحتوي على دالة تجري استدعاءات النظام نيابة عنك. يكمن جمال هذا النظام في أنه إذا دعم العتاد الأساسي آلية استدعاء نظام سريعة، فيمكن للنواة استخدامها لكونها منشئة المكتبة، وإلّا فيمكنها استخدام النظام القديم لإنشاء مصيدة. تسمى هذه المكتبة linux-gate.so.1 لأنها بوابة إلى عمل النواة الداخلي.

تضيف النواة مدخلةً إلى البنية auxv تسمَّى AT_SYSINFO_EHDR عندما تبدأ الرابط الديناميكي، وهذه المدخلة هي العنوان الموجود في الذاكرة الذي توجد فيه مكتبة النواة الخاصة. يمكن للرابط الديناميكي عندما يبدأ البحثَ عن المؤشر AT_SYSINFO_EHDR، فإن وُجد، فستُحمَّل تلك المكتبة للبرنامج. لا يملك البرنامج أيّ فكرة عن وجود هذه المكتبة، لأنها تُعَد ترتيبًا خاصًا بين الرابط الديناميكي والنواة.

ذكرنا أن المبرمجين يجرون استدعاءات النظام بطريقة غير مباشرة من خلال استدعاء الدوال في مكتبات النظام libc التي يمكنها التحقق مما إذا كان ملف النواة الثنائي الخاص محمَّلًا أم لا، فإذا كان الأمر كذلك، فيجب استخدام الدوال الموجودة ضمنه لإجراء استدعاءات النظام. إذا حددت النواة أن العتاد يمتلك القدرة المطلوبة، فيجب استخدام طريقة استدعاء النظام السريع.

بدء برنامج

تمرّر النواةُ المفسّرَ بعد تحميله إلى نقطة الدخول كما هو مذكور في ملف المفسّر (لاحظ عدم اختبار كيفية بدء الرابط الديناميكي). سيقفز الرابط الديناميكي إلى عنوان نقطة الدخول كما هو مذكور في ملف ELF الثنائي.

يوضح المثال التالي نتيجة تفكيك Disassembley بدء تشغيل البرنامج:

$ cat test.c

int main(void)
{
  return 0;
}

$ gcc -o test test.c

$ readelf --headers ./test | grep Entry
  Entry point address:               0x80482b0

$ objdump --disassemble ./test

[...]

080482b0 <_start>:
  80482b0:       31 ed                   xor    %ebp,%ebp
  80482b2:       5e                      pop    %esi
  80482b3:       89 e1                   mov    %esp,%ecx
  80482b5:       83 e4 f0                and    $0xfffffff0,%esp
  80482b8:       50                      push   %eax
  80482b9:       54                      push   %esp
  80482ba:       52                      push   %edx
  80482bb:       68 00 84 04 08          push   $0x8048400
  80482c0:       68 90 83 04 08          push   $0x8048390
  80482c5:       51                      push   %ecx
  80482c6:       56                      push   %esi
  80482c7:       68 68 83 04 08          push   $0x8048368
  80482cc:       e8 b3 ff ff ff          call   8048284 <__libc_start_main@plt>
  80482d1:       f4                      hlt
  80482d2:       90                      nop
  80482d3:       90                      nop

08048368 <main>:
  8048368:       55                      push   %ebp
  8048369:       89 e5                   mov    %esp,%ebp
  804836b:       83 ec 08                sub    $0x8,%esp
  804836e:       83 e4 f0                and    $0xfffffff0,%esp
  8048371:       b8 00 00 00 00          mov    $0x0,%eax
  8048376:       83 c0 0f                add    $0xf,%eax
  8048379:       83 c0 0f                add    $0xf,%eax
  804837c:       c1 e8 04                shr    $0x4,%eax
  804837f:       c1 e0 04                shl    $0x4,%eax
  8048382:       29 c4                   sub    %eax,%esp
  8048384:       b8 00 00 00 00          mov    $0x0,%eax
  8048389:       c9                      leave
  804838a:       c3                      ret
  804838b:       90                      nop
  804838c:       90                      nop
  804838d:       90                      nop
  804838e:       90                      nop
  804838f:       90                      nop

08048390 <__libc_csu_init>:
  8048390:       55                      push   %ebp
  8048391:       89 e5                   mov    %esp,%ebp
  [...]

08048400 <__libc_csu_fini>:
  8048400:       55                      push   %ebp
  [...]

يمكننا أن نرى في المثال البسيط السابق باستخدام أداة readelf أن نقطة الدخول هي الدالة ‎_start في الملف الثنائي، ويمكننا أن نرى في عملية التفكيك دفع بعض القيم إلى المكدس. تمثل القيمة الأولى 0x8048400 الدالة ‎__libc_csu_fini، وتمثل القيمة 0x8048390 الدالة ‎__libc_csu_init، وتمثل القيمة 0x8048368 الدالة الرئيسية main()‎، ثم تُستدعَى قيمة الدالة ‎__libc_start_main.

الدالة ‎__libc_start_main مُعرَّفة في مصادر مكتبة glibc ضمن sysdeps/generic/libc-start.c، وتُعَد معقدةً جدًا ومخفيةً بين عدد كبير من التعريفات، حيث يجب أن تكون قابلة للنقل عبر عدد كبير جدًا من الأنظمة والمعماريات التي يمكن لمكتبة glibc العمل عليها. تطبّق هذه الدالة عددًا من الأشياء المحدَّدة المتعلقة بإعداد مكتبة C والتي لا يحتاج المبرمج العادي للقلق بشأنها. النقطة التالية التي تستدعي فيها المكتبةُ البرنامجَ هي عند التعامل مع شيفرة init.

تُعَد الدالتان init وfini مفهومين خاصين يستدعيان أجزاءً من الشيفرة البرمجية الموجودة في المكتبات المشتركة والتي يمكن أن تحتاج لاستدعائها قبل أن تبدأ المكتبة أو عند إلغاء تحميل المكتبة على التوالي. يمكنك أن ترى كيف يمكن أن يكون ذلك مفيدًا لمبرمجي المكتبات لإعداد المتغيرات عند بدء تشغيل المكتبة أو لتنظيفها في النهاية. كان البحث عن الدالتين ‎_init و‎_fini في المكتبة ممكنًا سابقًا، ولكن أصبح ذلك مقيدًا إلى حد ما حيث كان كل شيء مطلوبًا في هاتين الدالتين. سنوضح فيما يلي كيفية عمل الدالتين init وfini فقط.

يمكننا أن نرى الآن أن الدالة ‎__libc_start_main ستتلقى عددًا من معاملات الدخل في المكدس stack، إذ سيكون بإمكانها أولًا الوصول إلى وسائط البرنامج ومتغيرات البيئة والمتجه المساعد من النواة، ثم ستدفع دالة التهيئة إلى عناوين المكدس الخاصة بالدوال للتعامل مع الدالتين init وfini ثم عنوان الدالة الرئيسية نفسها.

نحتاج طريقةً ما للإشارة إلى أنه يجب استدعاء دالةٍ ما باستخدام init أوfini في الشيفرة المصدرية. نستخدم مع gcc سمات Attributes لتمييز دالتين بأنهما بانيتان Constructors أو ومدمرتان Destructors في برنامجنا الرئيسي. تُستخدَم هذه المصطلحات بصورة أكثر شيوعًا مع اللغات كائنية التوجه لوصف دورات حياة الكائن.

إليك مثال عن الباني والمدمر:

$ cat test.c
#include <stdio.h>

void __attribute__((constructor)) program_init(void)  {
  printf("init\n");
}

void  __attribute__((destructor)) program_fini(void) {
  printf("fini\n");
}

int main(void)
{
  return 0;
}

$ gcc -Wall  -o test test.c

$ ./test
init
fini

$ objdump --disassemble ./test | grep program_init
08048398 <program_init>:

$ objdump --disassemble ./test | grep program_fini
080483b0 <program_fini>:

$ objdump --disassemble ./test 

[...]
08048280 <_init>:
  8048280:       55                      push   %ebp
  8048281:       89 e5                   mov    %esp,%ebp
  8048283:       83 ec 08                sub    $0x8,%esp
  8048286:       e8 79 00 00 00          call   8048304 <call_gmon_start>
  804828b:       e8 e0 00 00 00          call   8048370 <frame_dummy>
  8048290:       e8 2b 02 00 00          call   80484c0 <__do_global_ctors_aux>
  8048295:       c9                      leave
  8048296:       c3                      ret
[...]

080484c0 <__do_global_ctors_aux>:
  80484c0:       55                      push   %ebp
  80484c1:       89 e5                   mov    %esp,%ebp
  80484c3:       53                      push   %ebx
  80484c4:       52                      push   %edx
  80484c5:       a1 2c 95 04 08          mov    0x804952c,%eax
  80484ca:       83 f8 ff                cmp    $0xffffffff,%eax
  80484cd:       74 1e                   je     80484ed <__do_global_ctors_aux+0x2d>
  80484cf:       bb 2c 95 04 08          mov    $0x804952c,%ebx
  80484d4:       8d b6 00 00 00 00       lea    0x0(%esi),%esi
  80484da:       8d bf 00 00 00 00       lea    0x0(%edi),%edi
  80484e0:       ff d0                   call   *%eax
  80484e2:       8b 43 fc                mov    0xfffffffc(%ebx),%eax
  80484e5:       83 eb 04                sub    $0x4,%ebx
  80484e8:       83 f8 ff                cmp    $0xffffffff,%eax
  80484eb:       75 f3                   jne    80484e0 <__do_global_ctors_aux+0x20>
  80484ed:       58                      pop    %eax
  80484ee:       5b                      pop    %ebx
  80484ef:       5d                      pop    %ebp
  80484f0:       c3                      ret
  80484f1:       90                      nop
  80484f2:       90                      nop
  80484f3:       90                      nop


$ readelf --sections ./test
There are 34 section headers, starting at offset 0xfb0:

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .interp           PROGBITS        08048114 000114 000013 00   A  0   0  1
  [ 2] .note.ABI-tag     NOTE            08048128 000128 000020 00   A  0   0  4
  [ 3] .hash             HASH            08048148 000148 00002c 04   A  4   0  4
  [ 4] .dynsym           DYNSYM          08048174 000174 000060 10   A  5   1  4
  [ 5] .dynstr           STRTAB          080481d4 0001d4 00005e 00   A  0   0  1
  [ 6] .gnu.version      VERSYM          08048232 000232 00000c 02   A  4   0  2
  [ 7] .gnu.version_r    VERNEED         08048240 000240 000020 00   A  5   1  4
  [ 8] .rel.dyn          REL             08048260 000260 000008 08   A  4   0  4
  [ 9] .rel.plt          REL             08048268 000268 000018 08   A  4  11  4
  [10] .init             PROGBITS        08048280 000280 000017 00  AX  0   0  4
  [11] .plt              PROGBITS        08048298 000298 000040 04  AX  0   0  4
  [12] .text             PROGBITS        080482e0 0002e0 000214 00  AX  0   0 16
  [13] .fini             PROGBITS        080484f4 0004f4 00001a 00  AX  0   0  4
  [14] .rodata           PROGBITS        08048510 000510 000012 00   A  0   0  4
  [15] .eh_frame         PROGBITS        08048524 000524 000004 00   A  0   0  4
  [16] .ctors            PROGBITS        08049528 000528 00000c 00  WA  0   0  4
  [17] .dtors            PROGBITS        08049534 000534 00000c 00  WA  0   0  4
  [18] .jcr              PROGBITS        08049540 000540 000004 00  WA  0   0  4
  [19] .dynamic          DYNAMIC         08049544 000544 0000c8 08  WA  5   0  4
  [20] .got              PROGBITS        0804960c 00060c 000004 04  WA  0   0  4
  [21] .got.plt          PROGBITS        08049610 000610 000018 04  WA  0   0  4
  [22] .data             PROGBITS        08049628 000628 00000c 00  WA  0   0  4
  [23] .bss              NOBITS          08049634 000634 000004 00  WA  0   0  4
  [24] .comment          PROGBITS        00000000 000634 00018f 00      0   0  1
  [25] .debug_aranges    PROGBITS        00000000 0007c8 000078 00      0   0  8
  [26] .debug_pubnames   PROGBITS        00000000 000840 000025 00      0   0  1
  [27] .debug_info       PROGBITS        00000000 000865 0002e1 00      0   0  1
  [28] .debug_abbrev     PROGBITS        00000000 000b46 000076 00      0   0  1
  [29] .debug_line       PROGBITS        00000000 000bbc 0001da 00      0   0  1
  [30] .debug_str        PROGBITS        00000000 000d96 0000f3 01  MS  0   0  1
  [31] .shstrtab         STRTAB          00000000 000e89 000127 00      0   0  1
  [32] .symtab           SYMTAB          00000000 001500 000490 10     33  53  4
  [33] .strtab           STRTAB          00000000 001990 000218 00      0   0  1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings)
  I (info), L (link order), G (group), x (unknown)
  O (extra OS processing required) o (OS specific), p (processor specific)

$ objdump --disassemble-all --section .ctors ./test

./test:     file format elf32-i386

Contents of section .ctors:
  8049528 ffffffff 98830408 00000000           ............    

كانت دالة التهيئة ‎__libc_csu_init هي القيمة الأخيرة المدفوعة إلى المكدس من أجل الدالة ‎__libc_start_main. إذا اتبعنا سلسلة الاستدعاءات ابتداءً من ‎__libc_csu_init، فيمكننا أن نرى أنها تجري بعض الإعدادات ثم تستدعي الدالة ‎_init في الملف القابل للتنفيذ. تستدعي الدالة ‎_init في النهاية دالة تسمى ‎__do_global_ctors_aux، حيث إذا نظرنا إلى تفكيك هذه الدالة، فيمكننا أن نرى أنها تبدأ من العنوان 0x804952c ثم تتكرر وتقرأ قيمة وتستدعيها. هذا العنوان الذي يمثل البداية موجود في القسم ‎.ctors من الملف، حيث إذا ألقينا نظرة عليه، فسنرى أنه يحتوي على القيمة الأولى ‎-1 وعنوان الدالة بصيغة Big Endian أي تخزين البتات الأقل أهمية أولًا والقيمة صفر.

العنوان بصيغة Big Endian هو 0x08048398 أو عنوان الدالة program_init، لذا فإن صيغة القسم ‎.ctors هي ‎-1 أولًا ثم عنوان الدوال المطلوب استدعاؤها عند التهيئة، وأخيرًا القيمة صفر للإشارة إلى اكتمال القائمة. ستُستدعَى كل مدخلة، ولدينا في هذه الحالة دالة واحدة فقط.

أخيرًا، تستدعي الدالة ‎__libc_start_main الدالةَ الرئيسية main()‎ بمجرد اكتمالها باستدعاء الدالة ‎_init. تذكر أن هذه الدالة تمتلك إعداد المكدس الأولي باستخدام الوسائط ومؤشرات البيئة من النواة، وهذه هي الطريقة التي تحصل بها الدالة الرئيسية على الوسائط argc, argv[], envp[]‎. تعمل العملية بعد ذلك وتكتمل مرحلة الإعداد.

تحدث عملية مماثلة مع القسم ‎.dtors للمدمرين Destructors عند إنهاء البرنامج، حيث تستدعيها الدالة ‎__libc_start_main عند اكتمال الدالة الرئيسية main()‎.

لاحظ تطبيق الكثير من العمل قبل أن يبدأ البرنامج وحتى بعد أن تعتقد أنه انتهى بقليل.

ترجمة -وبتصرُّف- للقسم Starting a process من فصل Behind the process من كتاب Computer Science from the Bottom Up لصاحبه Ian Wienand.

اقرأ أيضًا

• المقال السابق: مفاهيم متقدمة متعلقة بصيغة ملفات ELF القابلة للتنفيذ
• كيفية إنشاء ملف قابل للتنفيذ Executable File من شيفرة برمجية مصدرية Source Code

تعرفنا في المقال السابق على الملفات القابلة للتنفيذ في نظام التشغيل وتمثيلها باستخدام الصيغة ELF وسنوضح في هذا المقال بعض المفاهيم المتعلقة بصيغة ملفات ELF مثل تنقيح الأخطاء Debugging وكيفية إنشاء أقسام مخصصة فيها وسكربتات الرابط Linker Scripts التي يستخدمها الرابط لبناء الأقسام Sections المُكوِّنة للمقاطع Segments، ولكن لنتعرّف أولًا على مفهوم ملفات ELF القابلة للتنفيذ.

ملفات ELF القابلة للتنفيذ

تُعَد الملفات القابلة للتنفيذ أحد الاستخدامات الأساسية لصيغة ELF. يحتوي الملف الثنائي على كل ما هو مطلوب لنظام التشغيل لتنفيذ الشيفرة البرمجية بالطريقة المطلوبة، حيث صُمِّم الملف التنفيذي لتشغيله في عملية ذات فضاء عناوين فريد، لذا يمكن للشيفرة البرمجية وضع افتراضات حول مكان تحميل أجزاء البرنامج المختلفة في الذاكرة.

يوضح المثال الآتي اختبار أجزاء ملفٍ قابل للتنفيذ باستخدام أداة readelf. يمكننا أن نرى العناوين الوهمية التي يجب وضع مقاطع LOAD فيها، حيث يمكننا أن نرى أنّ أحد هذه المقاطع مخصصٌ للشيفرة البرمجية ويمتلك أذونات القراءة والتنفيذ فقط، وهناك مقطع آخر مخصصٌ للبيانات ولديه أذونات القراءة والكتابة دون وجود أذونات التنفيذ، فبدونها لن تُميَّز الصفحات التي تدعم خطأ ما بأن لها أذونات التنفيذ حتى إن سمح هذا الخطأ للمهاجم بإدخال بيانات عشوائية، وبالتالي لن تسمح معظم المعالجات بأيّ تنفيذ للشيفرة البرمجية في تلك الصفحات.

$ readelf --segments /bin/ls

Elf file type is EXEC (Executable file)
Entry point 0x4046d4
There are 8 program headers, starting at offset 64

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x0000000000400040 0x0000000000400040
                 0x00000000000001c0 0x00000000000001c0  R E    8
  INTERP         0x0000000000000200 0x0000000000400200 0x0000000000400200
                 0x000000000000001c 0x000000000000001c  R      1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x0000000000019ef4 0x0000000000019ef4  R E    200000
  LOAD           0x000000000001a000 0x000000000061a000 0x000000000061a000
                 0x000000000000077c 0x0000000000001500  RW     200000
  DYNAMIC        0x000000000001a028 0x000000000061a028 0x000000000061a028
                 0x00000000000001d0 0x00000000000001d0  RW     8
  NOTE           0x000000000000021c 0x000000000040021c 0x000000000040021c
                 0x0000000000000044 0x0000000000000044  R      4
  GNU_EH_FRAME   0x0000000000017768 0x0000000000417768 0x0000000000417768
                 0x00000000000006fc 0x00000000000006fc  R      4
  GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000000 0x0000000000000000  RW     8

Section to Segment mapping:
  Segment Sections...
    00     
    01     .interp 
    02     .interp .note.ABI-tag .note.gnu.build-id .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame 
    03     .ctors .dtors .jcr .dynamic .got .got.plt .data .bss 
    04     .dynamic 
    05     .note.ABI-tag .note.gnu.build-id 
    06     .eh_frame_hdr 
    07

يجب تحميل مقاطع البرنامج على هذه العناوين، حيث تتمثل الخطوة الأخيرة للرابط Linker في تحليل معظم المنقولات Relocations وتصحيحها باستخدام العناوين المطلقة المُفترَضة، ثم تجاهل البيانات التي تصف الانتقال في الملف الثنائي النهائي دون وجود طريقة لإيجاد هذه المعلومات بعد الآن.

تحتوي الملفات القابلة للتنفيذ عمومًا على اعتماديات Dependencies خارجية للمكتبات المشتركة Shared Libraries أو أجزاء من الشيفرة البرمجية المشتركة يمكن تجريدها ومشاركتها بين أجزاء النظام بأكمله، حيث تتعلق جميع الأجزاء الغريبة في المثال السابق باستخدام المكتبات المشتركة التي سنوضّحها لاحقًا.

تنقيح الأخطاء Debugging

يُشار تقليديًا إلى الطريقة الأساسية لتنقيح أخطاء ما بعد التعطل باسم التفريغ الأساسي Core Dump، حيث يأتي مصطلح الأساسي Core من الخصائص الفيزيائية الأصلية للذاكرة المغناطيسية الأساسية التي تستخدم اتجاه الحلقات المغناطيسية الصغيرة لتخزين الحالة. يُعَد التفريغ الأساسي لقطة كاملة للبرنامج عند عمله في وقت معين، ويمكن بعد ذلك استخدام منقح أخطاء Debugger لفحص هذا التفريغ وإعادة بناء حالة البرنامج. يوضح المثال التالي نموذجًا لبرنامج يكتب في موقع ذاكرة عشوائية لغرض التعطل، حيث ستتوقف العمليات ويُسجَّل تفريغ للحالة الحالية:

$ cat coredump.c
int main(void) {
  char *foo = (char*)0x12345;
  *foo = 'a';

  return 0;
}

$ gcc -Wall -g -o coredump coredump.c

$ ./coredump
Segmentation fault (core dumped)

$ file ./core
./core: ELF 32-bit LSB core file Intel 80386, version 1 (SYSV), SVR4-style, from './coredump'

$ gdb ./coredump
...
(gdb) core core
[New LWP 31614]
Core was generated by `./coredump'.
Program terminated with signal 11, Segmentation fault.
#0  0x080483c4 in main () at coredump.c:3
3        *foo = 'a';
(gdb)

وبالتالي فإن ملف التفريغ الأساسي هو مجرد ملف ELF يحتوي على مجموعة من الأقسام التي يفهمها منقح الأخطاء لتمثيل أجزاء من البرنامج المُشغَّل.

الرموز ومعلومات تنقيح الأخطاء

يتطلب منقح الأخطاء gdb الملف القابل للتنفيذ الأصلي وملف التفريغ الأساسي لإعادة بناء بيئة جلسة تنقيح الأخطاء. لاحظ أن الملف القابل للتنفيذ الأصلي أُنشئ باستخدام الراية ‎-g التي توجه المصرِّف Compiler لتضمين جميع معلومات الأخطاء، حيث يجري الاحتفاظ بالمعلومات المتعلقة بعملية تنقيح الأخطاء الإضافية في أقسام خاصة من ملف ELF، إذ تصف هذه المعلومات بالتفصيل أشياءً مثل قيم المسجّل التي تحتوي حاليًا على المتغيرات المستخدمة في الشيفرة البرمجية وحجم المتغيرات وطول المصفوفات وغير ذلك. تكون هذه المعلومات بصيغة DWARF المعيارية التي تُعَد مرادفًا لصيغة ELF تقريبًا.

يمكن أن يؤدي تضمين معلومات تنقيح الأخطاء إلى جعل الملفات والمكتبات القابلة للتنفيذ كبيرة جدًا، إذ لا تزال تشغل مساحة كبيرة على القرص الصلب بالرغم من أنها ليست مطلوبة في الذاكرة للتشغيل الفعلي، وبالتالي يجب إزالة هذه المعلومات من ملف ELF. يمكن نقل كل من الملفات التي أًزيلت منها هذه المعلومات والملفات التي لم تًُزال منها هذه المعلومات، ولكن توفّر معظم طرق توزيع أو نشر الملفات الثنائية binary distribution الحالية معلومات لتنقيح الأخطاء في ملفات منفصلة. يمكن استخدام أداة objcopy لاستخراج معلومات تنقيح الأخطاء (‎--only-keep-debug) ثم إضافة رابط في الملف القابل للتنفيذ الأصلي إلى هذه المعلومات المُزالَة (‎--add-gnu-debuglink)، ثم سيكون هناك قسم خاص بالاسم ‎.gnu_debuglink موجود في الملف القابل للتنفيذ الأصلي ويحتوي على قيمة فريدة بحيث يمكن لمنقح الأخطاء عند بدء جلسات تنقيح الأخطاء التأكدَ من أنه يربط معلومات تنقيح الأخطاء الصحيحة بالملف التنفيذي الصحيح.

يوضح المثال التالي إزالة معلومات تنقيح الأخطاء إلى ملفات منفصلة باستخدام الأداة objcopy:

$ gcc -g -shared -o libtest.so libtest.c
$ objcopy --only-keep-debug libtest.so libtest.debug
$ objcopy --add-gnu-debuglink=libtest.debug libtest.so
$ objdump -s -j .gnu_debuglink libtest.so

libtest.so:     file format elf32-i386

Contents of section .gnu_debuglink:
 0000 6c696274 6573742e 64656275 67000000  libtest.debug...
 0010 52a7fd0a                             R...

تشغل الرموز مساحة أقل بكثير، ولكنها تُعَد هدفًا للإزالة من الخرج النهائي، إذ لن تكون هناك حاجة لبقاء معظم الرموز بمجرد ربط ملفات التعليمات المُصرَّفة object files لملف قابل للتنفيذ بالصورة النهائية. تُعَد الرموز مطلوبة لإصلاح مدخلات المنقولات Relocation، ولكن لن تكون الرموز بعد ذلك ضرورية تمامًا لتشغيل البرنامج النهائي. توفر سلسلة أدوات GNU لتجريد البرنامج في نظام لينكس خياراتٍ لإزالة الرموز. لاحظ أنه يجب تحليل بعض الرموز في وقت التشغيل (للربط الديناميكي Dynamic Linking)، ولكنها تُوضَع في جداول رموز ديناميكية منفصلة حتى لا تُزال وتجعل الخرج النهائي عديم الفائدة.

التفريغ الأساسي Coredump

يُعَد التفريغ الأساسي مجرد ملف ELF. يوضح المثال التالي مرونة صيغة ELF بوصفها صيغة ثنائية:

$ readelf --all ./core
ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              CORE (Core file)
  Machine:                           Intel 80386
  Version:                           0x1
  Entry point address:               0x0
  Start of program headers:          52 (bytes into file)
  Start of section headers:          0 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         15
  Size of section headers:           0 (bytes)
  Number of section headers:         0
  Section header string table index: 0

There are no sections in this file.

There are no sections to group in this file.

Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  NOTE           0x000214 0x00000000 0x00000000 0x0022c 0x00000     0
  LOAD           0x001000 0x08048000 0x00000000 0x01000 0x01000 R E 0x1000
  LOAD           0x002000 0x08049000 0x00000000 0x01000 0x01000 RW  0x1000
  LOAD           0x003000 0x489fc000 0x00000000 0x01000 0x1b000 R E 0x1000
  LOAD           0x004000 0x48a17000 0x00000000 0x01000 0x01000 R   0x1000
  LOAD           0x005000 0x48a18000 0x00000000 0x01000 0x01000 RW  0x1000
  LOAD           0x006000 0x48a1f000 0x00000000 0x01000 0x153000 R E 0x1000
  LOAD           0x007000 0x48b72000 0x00000000 0x00000 0x01000     0x1000
  LOAD           0x007000 0x48b73000 0x00000000 0x02000 0x02000 R   0x1000
  LOAD           0x009000 0x48b75000 0x00000000 0x01000 0x01000 RW  0x1000
  LOAD           0x00a000 0x48b76000 0x00000000 0x03000 0x03000 RW  0x1000
  LOAD           0x00d000 0xb771c000 0x00000000 0x01000 0x01000 RW  0x1000
  LOAD           0x00e000 0xb774d000 0x00000000 0x02000 0x02000 RW  0x1000
  LOAD           0x010000 0xb774f000 0x00000000 0x01000 0x01000 R E 0x1000
  LOAD           0x011000 0xbfeac000 0x00000000 0x22000 0x22000 RW  0x1000

There is no dynamic section in this file.

There are no relocations in this file.

There are no unwind sections in this file.

No version information found in this file.

Notes at offset 0x00000214 with length 0x0000022c:
  Owner                 Data size    Description
  CORE                 0x00000090    NT_PRSTATUS (prstatus structure)
  CORE                 0x0000007c    NT_PRPSINFO (prpsinfo structure)
  CORE                 0x000000a0    NT_AUXV (auxiliary vector)
  LINUX                0x00000030    Unknown note type: (0x00000200)

$ eu-readelf -n ./core

Note segment of 556 bytes at offset 0x214:
  Owner          Data size  Type
  CORE                 144  PRSTATUS
    info.si_signo: 11, info.si_code: 0, info.si_errno: 0, cursig: 11
    sigpend: <>
    sighold: <>
    pid: 31614, ppid: 31544, pgrp: 31614, sid: 31544
    utime: 0.000000, stime: 0.000000, cutime: 0.000000, cstime: 0.000000
    orig_eax: -1, fpvalid: 0
    ebx:     1219973108  ecx:     1243440144  edx:              1
    esi:              0  edi:              0  ebp:     0xbfecb828
    eax:          74565  eip:     0x080483c4  eflags:  0x00010286
    esp:     0xbfecb818
    ds: 0x007b  es: 0x007b  fs: 0x0000  gs: 0x0033  cs: 0x0073  ss: 0x007b
  CORE                 124  PRPSINFO
    state: 0, sname: R, zomb: 0, nice: 0, flag: 0x00400400
    uid: 1000, gid: 1000, pid: 31614, ppid: 31544, pgrp: 31614, sid: 31544
    fname: coredump, psargs: ./coredump 
  CORE                 160  AUXV
    SYSINFO: 0xb774f414
    SYSINFO_EHDR: 0xb774f000
    HWCAP: 0xafe8fbff  <fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov clflush dts acpi mmx fxsr sse sse2 ss tm pbe>
    PAGESZ: 4096
    CLKTCK: 100
    PHDR: 0x8048034
    PHENT: 32
    PHNUM: 8
    BASE: 0
    FLAGS: 0
    ENTRY: 0x8048300
    UID: 1000
    EUID: 1000
    GID: 1000
    EGID: 1000
    SECURE: 0
    RANDOM: 0xbfecba1b
    EXECFN: 0xbfecdff1
    PLATFORM: 0xbfecba2b
    NULL
  LINUX                 48  386_TLS
    index: 6, base: 0xb771c8d0, limit: 0x000fffff, flags: 0x00000051
    index: 7, base: 0x00000000, limit: 0x00000000, flags: 0x00000028
    index: 8, base: 0x00000000, limit: 0x00000000, flags: 0x00000028

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

المكون الآخر لملف التفريغ الأساسي هو أقسام الملاحظات NOTE التي تحتوي على البيانات الضرورية لتنقيح الأخطاء ولكن ليس بالضرورة أن تُلتقَط في لقطة مباشرة لتخصيصات الذاكرة. يوفّر برنامج eu-readelf المُستخدَم في الجزء الثاني من المثال السابق رؤيةً أكثر اكتمالًا للبيانات من خلال فك تشفيرها.

تقدّم الملاحظة PRSTATUS مجموعة من المعلومات حول العملية أثناء تشغيلها، فمثلًا يمكننا أن نرى من قيمة cursig أن البرنامج تلقى إشارة قيمتها 11 تمثل خطأ تقطيع segmentation fault. كما تتضمن بالإضافة إلى معلومات رقم العملية ملف تفريغ لجميع المسجلات الحالية. يمكن لمنقح الأخطاء بالنظر إلى قيم المسجّل إعادة بناء حالة المكدس وبالتالي توفير تعقب خلفي Backtrace، حيث يمكن لمنقح الأخطاء جنبًا إلى جنب مع الرمز ومعلومات تنقيح الأخطاء من الملف الثنائي الأصلي إظهار كيفية الوصول إلى نقطة التنفيذ الحالية.

من المخرجات الأخرى المتجه المساعد الحالي Auxiliary Vector أو AUXV اختصارًا. تصف 386_TLS مدخلات جدول الواصفات العام المستخدمة في تقديم Implementation معمارية x86 لمخزن محلي قائم على الخيوط thread-local storage. سيكون هناك مدخلات مكررة لكل خيط قيد التشغيل بالنسبة للتطبيق متعدد الخيوط، حيث سيفهم منقح الأخطاء ذلك وهذه هي الطريقة التي يطبّق بها منقح الأخطاء gdb الأمر thread لإظهار الخيوط والتبديل بينها.

تنشئ النواة ملف التفريغ الأساسي ضمن حدود إعدادات ulimit الحالية، إذ يمكن أن يؤدي البرنامج الذي يستخدم قدرًا كبيرًا من الذاكرة إلى وجود ملف تفريغ كبير جدًا، ويُحتمَل أن يملأ القرص الصلب ويزيد المشاكل سوءًا، ويُضبَط ulimit على مستوى منخفض أو حتى على القيمة الصفر لأن معظم الأشخاص الذين ليسوا مطورين لديهم استخدام ضئيل لملف التفريغ الأساسي. لكن يظل التفريغ الأساسي هو الطريقة الأكثر فائدة لتنقيح أخطاء حالة غير متوقعة بعد التعطل.

إنشاء أقسام مخصصة

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

يمكن لأداة modinfo فحص هذه المعلومات في وحدةٍ ما وتقديمها للمستخدم. يوضح المثال التالي استخدام مثال عن وحدة نواة لينكس fuse التي تسمح لمكتبات مساحة المستخدم بتوفير تقديمات نظام الملفات للنواة:

$ cd /lib/modules/$(uname -r)

$ sudo modinfo ./kernel/fs/fuse/fuse.ko 
filename:       /lib/modules/3.2.0-4-amd64/./kernel/fs/fuse/fuse.ko
alias:          devname:fuse
alias:          char-major-10-229
license:        GPL
description:    Filesystem in Userspace
author:         Miklos Szeredi <miklos@szeredi.hu>
depends:        
intree:         Y
vermagic:       3.2.0-4-amd64 SMP mod_unload modversions 
parm:           max_user_bgreq:Global limit for the maximum number of backgrounded requests an unprivileged user can set (uint)
parm:           max_user_congthresh:Global limit for the maximum congestion threshold an unprivileged user can set (uint)

$ objdump -s -j .modinfo ./kernel/fs/fuse/fuse.ko 

./kernel/fs/fuse/fuse.ko:     file format elf64-x86-64

Contents of section .modinfo:
 0000 616c6961 733d6465 766e616d 653a6675  alias=devname:fu
 0010 73650061 6c696173 3d636861 722d6d61  se.alias=char-ma
 0020 6a6f722d 31302d32 32390070 61726d3d  jor-10-229.parm=
 0030 6d61785f 75736572 5f636f6e 67746872  max_user_congthr
 0040 6573683a 476c6f62 616c206c 696d6974  esh:Global limit
 0050 20666f72 20746865 206d6178 696d756d   for the maximum
 0060 20636f6e 67657374 696f6e20 74687265   congestion thre
 0070 73686f6c 6420616e 20756e70 72697669  shold an unprivi
 0080 6c656765 64207573 65722063 616e2073  leged user can s
 0090 65740070 61726d74 7970653d 6d61785f  et.parmtype=max_
 00a0 75736572 5f636f6e 67746872 6573683a  user_congthresh:
 00b0 75696e74 00706172 6d3d6d61 785f7573  uint.parm=max_us
 00c0 65725f62 67726571 3a476c6f 62616c20  er_bgreq:Global 
 00d0 6c696d69 7420666f 72207468 65206d61  limit for the ma
 00e0 78696d75 6d206e75 6d626572 206f6620  ximum number of 
 00f0 6261636b 67726f75 6e646564 20726571  backgrounded req
 0100 75657374 7320616e 20756e70 72697669  uests an unprivi
 0110 6c656765 64207573 65722063 616e2073  leged user can s
 0120 65740070 61726d74 7970653d 6d61785f  et.parmtype=max_
 0130 75736572 5f626772 65713a75 696e7400  user_bgreq:uint.
 0140 6c696365 6e73653d 47504c00 64657363  license=GPL.desc
 0150 72697074 696f6e3d 46696c65 73797374  ription=Filesyst
 0160 656d2069 6e205573 65727370 61636500  em in Userspace.
 0170 61757468 6f723d4d 696b6c6f 7320537a  author=Miklos Sz
 0180 65726564 69203c6d 696b6c6f 7340737a  eredi <miklos@sz
 0190 65726564 692e6875 3e000000 00000000  eredi.hu>.......
 01a0 64657065 6e64733d 00696e74 7265653d  depends=.intree=
 01b0 59007665 726d6167 69633d33 2e322e30  Y.vermagic=3.2.0
 01c0 2d342d61 6d643634 20534d50 206d6f64  -4-amd64 SMP mod
 01d0 5f756e6c 6f616420 6d6f6476 65727369  _unload modversi
 01e0 6f6e7320 00                          ons .     

تحلّل الأداة modinfo القسم ‎.modinfo المُضمَّن في ملف الوحدة لتقديم تفاصيلها. يوضح المثال التالي كيفية وضع حقل "المؤلف Author" في الوحدة، حيث تأتي هذه الشيفرة البرمجية غالبًا من include/linux/module.h:

/*
 * ابدأ من الأسفل ثم انتقل إلى الأعلى
 */

 ‫/* وحدات الماكرو غير المباشرة مطلوبة للصق الوسيط المُوسَّع مثل الماكرو‫ __LINE__ */
#define ___PASTE(a,b) a##b
#define __PASTE(a,b) ___PASTE(a,b)


#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)

/* تحويل الماكرو غير المباشر إلى سلسلة نصية. يسمح إنشاء مستويين للمعامل بأن يكون ماكرو بحد ذاته، حيث يتحوّل‫ __stringify(FOO)‎ مثلًا إلى السلسلة "bar" عند التصريف باستخدام ‎-DFOO=bar.  */

#define __stringify_1(x...)     #x
#define __stringify(x...)       __stringify_1(x)

#define __MODULE_INFO(tag, name, info)                                    \
static const char __UNIQUE_ID(name)[]                                     \
  __used __attribute__((section(".modinfo"), unused, aligned(1)))         \
  = __stringify(tag) "=" info

‫/* معلومات عامة للصيغة‫ tag = "info"‎ */
#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)

/*
* ‫استخدم للمؤلفين المتعددين الذين يستخدمون "Name <email>‎" أو "Name" فقط 
‫تعليمات أو سطور MODULE_AUTHOR()‎ متعددة *  
*/
#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)

/* ---- */

MODULE_AUTHOR("Your Name <your@name.com>");

لنبدأ من الجزء السفلي حيث نرى أن الوحدة MODULE_AUTHOR تغلّف الماكرو الأعم ‎__MODULE_INFO، ويمكننا أن نرى أننا نبني متغيرًا من النوع static const char []‎ ليحتوي على السلسلة النصية "author=Your Name <your@name.com>‎". لاحظ أن المتغير لديه معامل إضافي ‎__attribute__((section(".modinfo")))‎ يخبر المصرّف بعدم وضع هذا المتغير في قسم البيانات data مع المتغيرات الأخرى، ولكن يمكن إخفاؤه في قسم ELF الخاص به الذي اسمه ‎.modinfo. توقِف المعاملات الأخرى المتغير الذي يجري تحسينه لأنه يبدو غير مُستخدَم وللتأكد من أننا نضع المتغيرات بجانب بعضها بعضًا من خلال تحديد المحاذاة.

هناك استخدام واسع النطاق لتحويل وحدات الماكرو إلى سلاسل نصية Stringification Macros، وهي حيل تُستخدَم في معالج لغة C المسبق لضمان أن السلاسل النصية والتعاريف يمكن أن تكون مع بعضها البعض. يوفّر المصرِّف gcc التعريف الخاص __COUNTER__ الذي يوفر قيمة فريدة ومتزايدة في كل استدعاء، مما يسمح باستدعاءات وحدة MODULE_AUTHOR متعددة في ملف واحد دون استخدام اسم المتغير نفسه.

يمكننا فحص الرموز الموضوعة في الوحدة النهائية لمعرفة النتيجة النهائية كما يلي:

$ objdump --syms ./fuse.ko | grep modinfo

0000000000000000 l    d  .modinfo    0000000000000000 .modinfo
0000000000000000 l     O .modinfo    0000000000000013 __UNIQUE_ID_alias1
0000000000000013 l     O .modinfo    0000000000000018 __UNIQUE_ID_alias0
000000000000002b l     O .modinfo    0000000000000011 __UNIQUE_ID_alias8
000000000000003c l     O .modinfo    000000000000000e __UNIQUE_ID_alias7
000000000000004a l     O .modinfo    0000000000000068 __UNIQUE_ID_max_user_congthresh6
00000000000000b2 l     O .modinfo    0000000000000022 __UNIQUE_ID_max_user_congthreshtype5
00000000000000d4 l     O .modinfo    000000000000006e __UNIQUE_ID_max_user_bgreq4
0000000000000142 l     O .modinfo    000000000000001d __UNIQUE_ID_max_user_bgreqtype3
000000000000015f l     O .modinfo    000000000000000c __UNIQUE_ID_license2
000000000000016b l     O .modinfo    0000000000000024 __UNIQUE_ID_description1
000000000000018f l     O .modinfo    000000000000002a __UNIQUE_ID_author0
00000000000001b9 l     O .modinfo    0000000000000011 __UNIQUE_ID_alias0
00000000000001d0 l     O .modinfo    0000000000000009 __module_depends
00000000000001d9 l     O .modinfo    0000000000000009 __UNIQUE_ID_intree1
00000000000001e2 l     O .modinfo    000000000000002f __UNIQUE_ID_vermagic0

سكربتات الرابط Linker Scripts

تتمثل وظيفة الرابط في بناء الأقسام Sections لتشكيل المقاطع Segments من خلال استخدام سكربت الرابط الذي يصِف مكان بدء المقاطع والأقسام الموجودة فيها ويحدد المعاملات الأخرى.

يوضح المثال الآتي مقتطفًا من سكربت الرابط الافتراضي الذي سيعرضه الرابط عند إعطاء الراية التفصيلية Verbose باستخدام الرايتين ‎-Wl و‎--verbose مع gcc. السكربت الافتراضي مُضمَّنٌ في الرابط ويعتمد على تعريفات واجهة API المعيارية لإنشاء برامج عاملة لمساحة مستخدمٍ خاصة بمنصة البناء.

$ gcc -Wl,--verbose -o test test.c
GNU ld (GNU Binutils for Debian) 2.26
...
using internal linker script:
==================================================
OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64",
          "elf64-x86-64")
OUTPUT_ARCH(i386:x86-64)
ENTRY(_start)
SEARCH_DIR("=/usr/local/lib/x86_64-linux-gnu"); ...
SECTIONS
{
  ‫/* أقسام للقراءة فقط مُدمَجة في مقطع النص‫ text segment: */
  PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
  .interp         : { *(.interp) }
  .note.gnu.build-id : { *(.note.gnu.build-id) }
  .hash           : { *(.hash) }
  .gnu.hash       : { *(.gnu.hash) }
  .dynsym         : { *(.dynsym) }
  .dynstr         : { *(.dynstr) }
  .gnu.version    : { *(.gnu.version) }
  .gnu.version_d  : { *(.gnu.version_d) }
  .gnu.version_r  : { *(.gnu.version_r) }
  .rela.dyn       :
    {
    ...
    }
  PROVIDE (etext = .);
  .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
  .rodata1        : { *(.rodata1) }
...

يمكنك أن ترى في المثال السابق كيف يحدد سكربت الرابط أمورًا متعددة مثل مواقع البدء والأقسام المراد تجميعها في مقاطع مختلفة. تُستخدَم الراية ‎-Wl لتمرير الراية ‎--verbose إلى الرابط عبر gcc، إذ يمكن توفير سكربتات مخصصة للرابط باستخدام الرايات. ليس مُحتمًلًا أن يحتاج مطورو مساحة المستخدم العادية إلى تجاوز سكربت الرابط الافتراضي، ولكن تتطلب التطبيقات المخصَّصة جدًا مثل عمليات بناء النواة سكربتات مخصصة للرابط في أغلب الأحيان.

ترجمة -وبتصرُّف- للقسمين ELF Executables و Extending ELF concepts من فصل Behind the process من كتاب Computer Science from the Bottom Up لصاحبه Ian Wienand.

اقرأ أيضًا

• المقال التالي: مفهوم الربط الديناميكي Dynamic Linking في معمارية الحاسوب
• المقال السابق: الملفات القابلة للتنفيذ في نظام التشغيل وتمثيلها باستخدام الصيغة ELF
• تطبيق عملي لبناء برنامج تنفيذي من شيفرة مصدرية بلغة C

يحتوي البرنامج الذي يعمل في الذاكرة على مكونين رئيسيين هما: الشيفرة البرمجية Code المعروفة أيضًا باسم النص Text والبيانات Data. لا يبقى الملف القابل للتنفيذ في الذاكرة، ولكنه يقضي معظم وقته بوصفه ملفًا على القرص الصلب ينتظر تحميله عند التشغيل. يُعَد الملف مجرد مصفوفة متجاورة من البتات، لذا تبتكر جميع الأنظمة طرقًا لتنظيم الشيفرة البرمجية والبيانات ضمن الملفات للتنفيذ عند الطلب، حيث يشار إلى هذه الصيغة من الملفات باسم ملف ثنائي Binary أو ملف قابل للتنفيذ Executable، وتكون البتات والبايتات الخاصة بالملف بصيغة جاهزة لوضعها في الذاكرة وتفسيرها مباشرةً بواسطة عتاد المعالج.

تمثيل الملفات القابلة للتنفيذ

يجب أن تحدّد أيّ صيغة لملفٍ قابل للتنفيذ executable file مكانَ وجود الشيفرة البرمجية والبيانات في الملف الثنائي، حيث تُعَد الشيفرة البرمجية والبيانات القسمين الأساسيين لملفٍ قابل للتنفيذ، وأحد المكونات الإضافية التي لم نذكرها حتى الآن هو مساحة تخزين المتغيرات العامة غير المُهيَّأة uninitialised global variables.

إذا صرّحنا عن متغير وأعطيناه قيمة أولية، فيجب تخزين هذه القيمة في ملف قابل للتنفيذ بحيث يمكن تهيئته بالقيمة الصحيحة عند بدء البرنامج، ولكن هناك العديد من المتغيرات غير المهيأة أو التي قيمتها صفر عند تنفيذ البرنامج لأول مرة. يُعَد حجز مساحة لهذه المتغيرات في الملف القابل للتنفيذ ثم تخزين قيم صفرية أو فارغة NULL هدرًا للمساحة، مما يؤدي إلى تضخّم حجم الملف القابل للتنفيذ على القرص الصلب دون داع لذلك. تُعرِّف معظم الصيغ الثنائية مفهوم القسم BSS الإضافي بوصفه حجمًا بديلًا للبيانات الصفرية غير المُهيَّأة. يمكن تخصيص الذاكرة الإضافية التي يحدّدها القسم BSS وضبطها على القيمة صفر عند تحميل البرنامج. يرمز الاختصار BSS إلى العبارة Block Started by Symbol، وهو أمر بلغة تجميع حاسوب IBM القديم، ولكن يُرجَّح أن الاشتقاق الدقيق له ضاع مع الوقت.

الصيغة الثنائية Binary Format

يُنشَأ الملف القابل بالتنفيذ باستخدام سلسلة أدوات من الشيفرة المصدرية، حيث يجب أن يكون هذا الملف بصيغة محددة وواضحة بحيث يمكن للمصرِّف إنشاؤه ويمكن لنظام التشغيل تحديده وتحميله في الذاكرة وتحويله إلى عملية مُشغَّلة يمكن لنظام التشغيل إدارتها. يمكن أن تكون هذه الصيغة من الملفات القابلة للتنفيذ خاصة بنظام التشغيل، إذ لا نتوقع تنفيذ برنامج مُصرَّف لنظامٍ ما على نظام آخر مثل أن تعمل برامج ويندوز على نظام لينكس أو أن تعمل برامج لينكس على نظام macOS.

لكن خيط المعالجة Thread المشترك بين جميع صيغ الملفات القابلة للتنفيذ هو أنها تتضمن ترويسة معيارية مُعرَّفة مسبقًا توضّح كيفية تخزين شيفرة وبيانات البرنامج في بقية الملف، حيث يمكن أن تشرح ذلك بالكلمات مثل أن نقول: "تبدأ شيفرة البرنامج من 20 بايت في هذا الملف، ويبلغ طولها 50 كيلوبايت، وتتبعها بيانات البرنامج ويبلغ طولها 20 كيلوبايت".

هناك صيغة معينة أصبحت في الآونة الأخيرة معيارًا لتمثيل الملفات القابلة للتنفيذ في الأنظمة الحديثة القائمة على نظام يونكس، ويطلَق على هذا التنسيق بصيغة الرابط والملفات القابلة للتنفيذ Executable and Linker Format -أو ELF اختصارًا، حيث سنشرحها بمزيد من التفصيل لاحقًا.

تاريخ الصيغة الثنائية

سنوضح فيما يلي صيغتين للملفات الثنائية سبقت ظهور صيغة ملفات ELF هما a.out و COFF.

a.out

لم تكن صيغة ملفات ELF المعيار دائمًا، إذ استخدمت أنظمة يونكس الأصلية صيغة ملف بالاسم a.out. يمكننا أن نرى آثار ذلك عند تصريف برنامج بدون الخيار ‎-o لتحديد اسم ملف الخرج، حيث سينشأ الملف القابل للتنفيذ بالاسم الافتراضي a.out الذي يُعَد اسم ملف الخرج الافتراضي الناتج عن الرابط Linker. يستخدم المصرِّف Compiler أسماء الملفات المُنشَأة عشوائيًا بوصفها ملفات وسيطة لشيفرة التجميع والشيفرة المُصرَّفة.

a.out هو صيغة ترويسة بسيطة تسمح فقط بقسم واحد للبيانات والشيفرة وBSS، وهذا غير كافٍ للأنظمة الحديثة ذات المكتبات الديناميكية.

COFF

كانت صيغة ملف التعليمات المُصرَّفة المشترك Common Object File Format -أو COFF اختصارًا- مقدمة لظهور صيغة ملفات ELF، حيث كانت صيغة ترويستها أكثر مرونة، مما يسمح بمزيد -ولكن محدود- من الأقسام في الملف.

تواجه صيغة COFF صعوبات في دعم المكتبات المشتركة، لذا اختيرت صيغة ELF بوصفها تقديمًا Implementation بديلًا على نظام لينكس. لكن توجد صيغة COFF في مايكروسوفت ويندوز بوصفها صيغة ملفات قابلة للتنفيذ والنقل Portable Executable -أو PE اختصارًا- التي تُعَد بالنسبة إلى ويندوز مثل صيغة ملفات ELF في لينكس.

صيغة ملفات ELF

تُعَد صيغة ملفات ELF صيغةً مرنة لتمثيل الشيفرة الثنائية في النظام، حيث يمكنك باتباع معيار ELF تمثيل النواة Kernel ثنائيًا بسهولة مثل تمثيل ملف قابل للتنفيذ أو مكتبة نظام عادية. يمكن استخدام الأدوات نفسها لفحص وتشغيل جميع ملفات ELF ويمكن للمطورين الذين يفهمون صيغة ملفات ELF الاستفادة من مهاراتهم في معظم الأنظمة الحديثة المبنية على يونكس.

توسّع الصيغة ELF صيغة الملفات COFF وتمنح الترويسة مرونة كافية لتحديد عدد عشوائي من الأقسام، بحيث يكون لكل منها خاصياته الخاصة، مما يسهّل الربط الديناميكي وتنقيح الأخطاء Debugging.

ترويسة ملفات ELF

يحتوي الملف على ترويسة ملف File Header تصِف الملف، ثم يحتوي على مؤشرات لكل قسم من الأقسام التي يتكون منها الملف. يوضح المثال التالي الوصف على النحو الوارد في توثيق واجهة برمجة تطبيقات ELF32 (نموذج 32 بت من صيغة ملفات ELF)، وهو تخطيط لبنية لغة C الذي يعرّف ترويسة ELF:

typedef struct {
  unsigned char e_ident[EI_NIDENT];
  Elf32_Half    e_type;
  Elf32_Half    e_machine;
  Elf32_Word    e_version;
  Elf32_Addr    e_entry;
  Elf32_Off     e_phoff;
  Elf32_Off     e_shoff;
  Elf32_Word    e_flags;
  Elf32_Half    e_ehsize;
  Elf32_Half    e_phentsize;
  Elf32_Half    e_phnum;
  Elf32_Half    e_shentsize;
  Elf32_Half    e_shnum;
  Elf32_Half    e_shstrndx;
} Elf32_Ehdr;

إليك مثال عن ترويسة ELF كما هو موضح باستخدام الأداة readelf:

$ readelf --header /bin/ls

ELF Header:
  Magic:   7f 45 4c 46 01 02 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, big endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           PowerPC
  Version:                           0x1
  Entry point address:               0x10002640
  Start of program headers:          52 (bytes into file)
  Start of section headers:          87460 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         8
  Size of section headers:           40 (bytes)
  Number of section headers:         29
  Section header string table index: 28

  [...]

يوضّح المثال السابق نموذجًا سهل القراءة على الإنسان كما مولدًا باستخدام برنامج readelf، وهو جزء من أدوات Binutils في GNU.

تُوجَد المصفوفة e_ident في بداية أيّ ملف ELF، وتبدأ دائمًا بمجموعة بايتات سحرية. البايت الأول هو 0x7F ثم الثلاثة بايتات التالية هي "ELF". يمكنك فحص ملف ELF الثنائي لترى ذلك بنفسك باستخدام الأمر hexdump.

يفحص المثال التالي عدد ELF السحري:

ianw@mingus:~$ hexdump -C /bin/ls | more
00000000  7f 45 4c 46 01 02 01 00  00 00 00 00 00 00 00 00  |.ELF............|

... (يتبع ذلك بقية البرنامج) …

لاحظ وجود البت 0x7F في البداية ثم سلسلة آسكي ASCII المُشفَّرة "ELF". ألقِ نظرة على المعيار وشاهد ما تعرّفه بقية المصفوفة وما هي القيم الموجودة في الملف الثنائي. لدينا بعد ذلك بعض الرايات Flags لنوع الجهاز الذي اُنشِئ هذا الملف الثنائي من أجله. لاحظ أن صيغة ELF تعرّف إصدارات مختلفة من الأحجام مثل إصدارات 32 بت و64 بت، حيث سنشرح هنا الإصدار 32 بت. يكمن الاختلاف في أنه يجب الاحتفاظ بالعناوين على أجهزة 64 بت في متغيرات بحجم 64 بتًا. يمكننا أن نرى أن الملف الثنائي أُنشِئ للجهاز الذي يستخدم صيغة Big Endian (تخزين البتات الأقل أهمية أولًا)، حيث يستخدم هذا الجهاز المكمل الثنائي لتمثيل الأعداد السالبة. لاحظ بعد ذلك أن الخاصية Machine تخبرنا أنه جهاز PowerPC الثنائي.

يبدو أن عنوان نقطة الدخول واضح وصريح بدرجة كافية، وهو العنوان الموجود في الذاكرة الذي تبدأ منه شيفرة البرنامج. يُقال لمبرمجي لغة C المبتدئين أن الدالة الرئيسية main()‎ هي أول برنامج يُستدعَى في برامجهم، ولكن يمكننا التحقق من أنه ليس كذلك باستخدام عنوان نقطة الدخول كما يلي:

$ cat test.c
#include <stdio.h>

int main(void)
{
  printf("main is : %p\n", &main);
  return 0;
}

$ gcc -Wall -o test test.c

$ ./test
main is : 0x10000430

$ readelf --headers ./test | grep 'Entry point'
  Entry point address:               0x100002b0

$ objdump --disassemble ./test | grep 100002b0
100002b0 <_start>:
100002b0:       7c 29 0b 78     mr      r9,r1

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

تحتوي الترويسة بعد ذلك على مؤشرات إلى المكان الموجود في الملف الذي تبدأ فيه الأجزاء المهمة الأخرى من ملف ELF مثل جدول المحتويات.

الرموز Symbols 3 والمنقولات Relocation

توفر مواصفات ملف ELF جداول رموز Symbol Tables تربط بين السلاسل النصية أو الرموز ومواقع في الملف. تُعَد الرموز مطلوبة للربط Linking، فمثلًا يمكن أن يتطلب إسنادُ قيمة للمتغير foo المُصرَّح عنه بالشكل extern int foo رابطًا للعثور على عنوان المتغير foo، والذي يمكن أن يتضمن البحث عن الكلمة "foo" في جدول الرموز وإيجاد العنوان.

ترتبط المنقولات Relocations ارتباطًا وثيقًا بالرموز، حيث يُعَد الانتقال مساحةً فارغة تُترَك لإصلاحها لاحقًا، إذ لا يمكن استخدام المتغير foo في المثال السابق حتى معرفة عنوانه، ولكن نعلم في نظام 32 بت أن عنوان المتغير foo يجب أن يكون بقيمة 4 بايتات، لذلك يمكن للمصرِّف ببساطة ترك مساحة فارغة بمقدار 4 بايتات والاحتفاظ بانتقالٍ Relocation يخبر الرابط بأن يضع القيمة الحقيقية للمتغير foo في هذه المساحة التي مقدارها 4 بايتات في هذا العنوان في أيّ وقت يحتاج فيه المصرِّف استخدامَ هذا العنوان لإسناد قيمة مثلًا، ولكن يتطلب ذلك تحليل الرمز "foo".

المقاطع Segments والأقسام Sections

تحدد صيغة ELF عرضين لملف ELF، حيث يُستخدَم أحدهما للربط والآخر للتنفيذ، مما يوفر مرونة كبيرة لمصممي الأنظمة. سنتحدث عن الأقسام الموجودة في شيفرة الكائن التي تنتظر أن تُربَط بملف قابل للتنفيذ، ويُربَط قسم واحد أو أكثر مع مقطعٍ ما في الملف القابل للتنفيذ.

المقاطع Segments

من الأسهل في بعض الأحيان النظر إلى المستوى الأعلى من التجريد abstraction المتمثل بالمقاطع قبل فحص الطبقات السفلية. يحتوي ملف ELF على ترويسة تصف تخطيط الملف العام، حيث تشير ترويسة ELF إلى مجموعة أخرى من الترويسات تسمى ترويسات البرامج Program Headers، حيث تصِف هذه الترويسات لنظام التشغيل أيّ شيء يمكن أن يكون مطلوبًا لتحميل الملف الثنائي في الذاكرة وتنفيذه. كما تصف ترويسات البرامج المقاطع، ولكن هناك بعض الأشياء الأخرى المطلوبة لتشغيل الملف القابل للتنفيذ.

إليك مثال عن ترويسة برنامج:

typedef struct {
  Elf32_Word p_type;
  Elf32_Off  p_offset;
  Elf32_Addr p_vaddr;
  Elf32_Addr p_paddr;
  Elf32_Word p_filesz;
  Elf32_Word p_memsz;
  Elf32_Word p_flags;
  Elf32_Word p_align;
}

يوضح المثال السابق تعريف ترويسة البرنامج. لا بد أنك لاحظت من تعريف ترويسة ELF سابقًا وجود الحقول e_phoff وe_phnum وe_phentsize التي تمثّل الإزاحة في الملف حيث تبدأ ترويسات البرامج وعدد ترويسات البرامج الموجودة وحجم كل ترويسة برنامج، وبالتالي يمكنك العثور على ترويسات البرامج وقراءتها بسهولة باستخدام هذه الأجزاء الثلاثة من المعلومات.

تُعَد ترويسات البرامج أكثر من مجرد مقاطع، حيث يعرّف الحقل p_type ما تعرّفه ترويسة البرنامج، فمثلًا إذا كان هذا الحقل هو PT_INTERP، فستُعرَّف الترويسة بأنها مؤشر سلسلة نصية يؤشّر إلى مفسّر Interpreter الملف الثنائي. ناقشنا سابقًا الفرق بين اللغات المُصرَّفة Compiled واللغات المُفسَّرة Interpreted وميّزنا المُصرِّف بأنه ينشئ ملفًا ثنائيًا يمكن تشغيله بطريقة مستقلة. لكن لا بد أنك تتساءل عن سبب حاجتنا لمفسّر! حسنًا، ترغب الأنظمة الحديثة في المرونة عند تحميل الملفات القابلة للتنفيذ، لذا لا يمكن الحصول على بعض المعلومات بصورة كافية إلّا في الوقت الفعلي الذي يُعَد فيه البرنامج للتشغيل، وهذا ما يسمى بالربط الديناميكي Dynamic Linking الذي سنتحدث عنه لاحقًا، وبالتالي يجب إجراء بعض التغييرات الطفيفة على البرنامج الثنائي للسماح له بالعمل بصورة صحيحة في وقت التشغيل. لذا يُعَد مفسّر الملف الثنائي المعتاد هو المحمّل الديناميكي Dynamic Loader، لأنه يأخذ الخطوات النهائية لإكمال تحميل الملف القابل للتنفيذ وإعداد الصورة الثنائية للتشغيل.

تصف القيمة PT_LOAD في الحقل p_type المقاطع، ثم تصف الحقول الأخرى في ترويسة البرنامج كلّ مقطع منها. يخبرك الحقل p_offset بمقدار بُعد بيانات المقطع عن الملف الموجود على القرص الصلب. بينما يخبرك الحقل p_vaddr بالعنوان الذي يجب أن توجد عنده البيانات في الذاكرة الوهمية Virtual Memory، حيث يصف الحقل p_addr العنوان الحقيقي Physical Address الذي يُعَد مفيدًا للأنظمة المدمَجة الصغيرة التي لا تطبّق الذاكرة الوهمية. تخبرك الرايتان p_filesz وp_memsz بحجم المقطع الموجود على القرص الصلب وكم يجب أن يكون حجمه في الذاكرة. إذا كان حجم الذاكرة أكبر من حجم القرص الصلب، فيجب ملء التداخل بينهما بالأصفار، وبالتالي يمكنك توفير مساحة كبيرة في ملفاتك الثنائية من خلال عدم الاضطرار إلى هدر مساحة للمتغيرات العامة الفارغة. أخيرًا، يشير الحقل p_flags إلى أذونات المقطع، حيث يمكن تحديد أذونات التنفيذ والقراءة والكتابة، فمثلًا يجب تمييز مقاطع الشيفرة البرمجية بأنها للقراءة والتنفيذ فقط، وتمييز أقسام البيانات للقراءة والكتابة فقط بدون تنفيذ.

هناك عدد من أنواع المقاطع الأخرى المُعرَّفة في ترويسات البرامج الموصوفة كاملةً في مواصفات المعايير.

الأقسام Sections

تشكّل الأقسام مقاطعًا، حيث تُعَد الأقسام طريقة لتنظيم الملف الثنائي في مناطق منطقية لتوصيل المعلومات بين المصرِّف والرابط. تُستخدَم الأقسام في بعض الملفات الثنائية الخاصة مثل نواة لينكس Linux Kernel بطرق أكثر تحديدًا سنوضحها لاحقًا.

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

typedef struct {
  Elf32_Word sh_name;
  Elf32_Word sh_type;
  Elf32_Word sh_flags;
  Elf32_Addr sh_addr;
  Elf32_Off  sh_offset;
  Elf32_Word sh_size;
  Elf32_Word sh_link;
  Elf32_Word sh_info;
  Elf32_Word sh_addralign;
  Elf32_Word sh_entsize;
}

تحتوي الأقسام على عدد من الأنواع المُعرَّفة للحقل sh_type مثل تعريف قسم من النوع SH_PROGBITS بوصفه قسمًا يحتوي على بيانات ثنائية يستخدمها البرنامج. تشير الرايات الأخرى إلى ما إذا كان هذا القسم جدولَ رموز يستخدمه الرابط أو منقح الأخطاء مثلًا أو يمكن أن يكون شيئًا ما خاصًا بالمحمّل الديناميكي. كما توجد سمات إضافية مثل سمة التخصيص Allocate التي تشير إلى أن هذا القسم سيحتاج إلى ذاكرة مخصصة له.

سنختبر الآن البرنامج الموضح في المثال التالي:

#include <stdio.h>

int big_big_array[10*1024*1024];

char *a_string = "Hello, World!";

int a_var_with_value = 0x100;

int main(void)
{
  big_big_array[0] = 100;
  printf("%s\n", a_string);
  a_var_with_value += 20;
}

يوضح المثال التالي خرج الأداة readelf مع بعض الأجزاء الأخرى، حيث يمكننا باستخدام هذا الخرج تحليل كل جزء من برنامجنا البسيط السابق ومعرفة ما سيحدث به في خرج الملف الثنائي النهائي:

$ readelf --all ./sections
ELF Header:
  ...
    Size of section headers:           40 (bytes)
    Number of section headers:         37
    Section header string table index: 34

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .interp           PROGBITS        10000114 000114 00000d 00   A  0   0  1
  [ 2] .note.ABI-tag     NOTE            10000124 000124 000020 00   A  0   0  4
  [ 3] .hash             HASH            10000144 000144 00002c 04   A  4   0  4
  [ 4] .dynsym           DYNSYM          10000170 000170 000060 10   A  5   1  4
  [ 5] .dynstr           STRTAB          100001d0 0001d0 00005e 00   A  0   0  1
  [ 6] .gnu.version      VERSYM          1000022e 00022e 00000c 02   A  4   0  2
  [ 7] .gnu.version_r    VERNEED         1000023c 00023c 000020 00   A  5   1  4
  [ 8] .rela.dyn         RELA            1000025c 00025c 00000c 0c   A  4   0  4
  [ 9] .rela.plt         RELA            10000268 000268 000018 0c   A  4  25  4
  [10] .init             PROGBITS        10000280 000280 000028 00  AX  0   0  4
  [11] .text             PROGBITS        100002b0 0002b0 000560 00  AX  0   0 16
  [12] .fini             PROGBITS        10000810 000810 000020 00  AX  0   0  4
  [13] .rodata           PROGBITS        10000830 000830 000024 00   A  0   0  4
  [14] .sdata2           PROGBITS        10000854 000854 000000 00   A  0   0  4
  [15] .eh_frame         PROGBITS        10000854 000854 000004 00   A  0   0  4
  [16] .ctors            PROGBITS        10010858 000858 000008 00  WA  0   0  4
  [17] .dtors            PROGBITS        10010860 000860 000008 00  WA  0   0  4
  [18] .jcr              PROGBITS        10010868 000868 000004 00  WA  0   0  4
  [19] .got2             PROGBITS        1001086c 00086c 000010 00  WA  0   0  1
  [20] .dynamic          DYNAMIC         1001087c 00087c 0000c8 08  WA  5   0  4
  [21] .data             PROGBITS        10010944 000944 000008 00  WA  0   0  4
  [22] .got              PROGBITS        1001094c 00094c 000014 04 WAX  0   0  4
  [23] .sdata            PROGBITS        10010960 000960 000008 00  WA  0   0  4
  [24] .sbss             NOBITS          10010968 000968 000000 00  WA  0   0  1
  [25] .plt              NOBITS          10010968 000968 000060 00 WAX  0   0  4
  [26] .bss              NOBITS          100109c8 000968 2800004 00  WA  0   0  4
  [27] .comment          PROGBITS        00000000 000968 00018f 00      0   0  1
  [28] .debug_aranges    PROGBITS        00000000 000af8 000078 00      0   0  8
  [29] .debug_pubnames   PROGBITS        00000000 000b70 000025 00      0   0  1
  [30] .debug_info       PROGBITS        00000000 000b95 0002e5 00      0   0  1
  [31] .debug_abbrev     PROGBITS        00000000 000e7a 000076 00      0   0  1
  [32] .debug_line       PROGBITS        00000000 000ef0 0001de 00      0   0  1
  [33] .debug_str        PROGBITS        00000000 0010ce 0000f0 01  MS  0   0  1
  [34] .shstrtab         STRTAB          00000000 0011be 00013b 00      0   0  1
  [35] .symtab           SYMTAB          00000000 0018c4 000c90 10     36  65  4
  [36] .strtab           STRTAB          00000000 002554 000909 00      0   0  1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings)
  I (info), L (link order), G (group), x (unknown)
  O (extra OS processing required) o (OS specific), p (processor specific)

There are no section groups in this file.
 ...

Symbol table '.symtab' contains 201 entries:
  Num:    Value  Size Type    Bind   Vis      Ndx Name
...
    99: 100109cc 0x2800000 OBJECT  GLOBAL DEFAULT   26 big_big_array
...
   110: 10010960     4 OBJECT  GLOBAL DEFAULT   23 a_string
...
   130: 10010964     4 OBJECT  GLOBAL DEFAULT   23 a_var_with_value
...
   144: 10000430    96 FUNC    GLOBAL DEFAULT   11 main

لنلقِ أولًا نظرة على المتغير big_big_array الذي -كما يوحي الاسم- هو مصفوفة عامة كبيرة إلى حد ما، وإذا انتقلنا إلى جدول الرموز، فيمكننا أن نرى أن هذا المتغير موجود في الموقع 0x100109cc الذي يمكننا ربطه بالقسم ‎.bss في قائمة الأقسام لأنه يبدأ تحته مباشرةً عند الموقع 0x100109c8، ولاحظ حجمه الكبير جدًا.

ذكرنا أن القسم BSS هو جزء معياري من صورة ثنائية، لأنه ليس منطقيًا أن تطلب أن يكون لملفٍ ثنائي على القرص الصلب 10 ميجابايتات من المساحة المخصَّصة له عندما تكون كل هذه المساحة قيمًا صفرية. لاحظ أن هذا القسم يحتوي على النوع NOBITS، مما يعني أنه لا يحتوي على أيّ بايت على القرص الصلب. لذا يُعرَّف القسم ‎.bss للمتغيرات العامة التي يجب أن تكون قيمتها صفرًا عند بدء البرنامج. رأينا كيف يمكن أن يختلف حجم الذاكرة عن حجم القرص الصلب عند مناقشتنا للمقاطع، فوجود المتغيرات في القسم ‎.bss دليل على أنها ستُعطَى قيمة صفرية عند بدء البرنامج.

يوجد المتغير a_string في القسم ‎.sdata الذي يمثّل البيانات الصغيرة Small Data، حيث يُعَد هذا القسم وقسم ‎.sbss المقابل له أقسامًا متوفرة في بعض المعماريات حيث يمكن الوصول إلى البيانات باستخدام الإزاحة عن بعض المؤشرات المعروفة، وهذا يعني أنه يمكن إضافة قيمة ثابتة إلى العنوان الأساسي، مما يجعل الوصول إلى البيانات في الأقسام أسرع نظرًا لعدم وجود عمليات بحث مطلوبة إضافية وتحميل للعناوين في الذاكرة. تقتصر معظم المعماريات على حجم القيم الفورية Immediate Value التي يمكنك إضافتها إلى المسجل مثل القيمة الفورية 70 عند تطبيق التعليمة r1 = add r2, 70;‎ على عكس جمع قيمتين مخزنتين في مسجلين r1 = add r2,r3، وبالتالي يمكن تطبيق إزاحة بمقدار مسافة صغيرة معينة عن العنوان. يمكننا أيضًا أن نرى أن المتغير a_var_with_value يوجد في المكان نفسه.

بينما توجد الدالة الرئيسية main في القسم ‎.text. تذكر أن "النص Text" و"الشيفرة Code" يُستخدَمان للإشارة إلى برنامج في الذاكرة.

الأقسام والمقاطع مع بعضها البعض

إليك مثال يحتوي على الأقسام والمقاطع مع بعضها البعض:

$ readelf --segments /bin/ls

Elf file type is EXEC (Executable file)
Entry point 0x100026c0
There are 8 program headers, starting at offset 52

Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  PHDR           0x000034 0x10000034 0x10000034 0x00100 0x00100 R E 0x4
  INTERP         0x000154 0x10000154 0x10000154 0x0000d 0x0000d R   0x1
    [Requesting program interpreter: /lib/ld.so.1]
  LOAD           0x000000 0x10000000 0x10000000 0x14d5c 0x14d5c R E 0x10000
  LOAD           0x014d60 0x10024d60 0x10024d60 0x002b0 0x00b7c RWE 0x10000
  DYNAMIC        0x014f00 0x10024f00 0x10024f00 0x000d8 0x000d8 RW  0x4
  NOTE           0x000164 0x10000164 0x10000164 0x00020 0x00020 R   0x4
  GNU_EH_FRAME   0x014d30 0x10014d30 0x10014d30 0x0002c 0x0002c R   0x4
  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RWE 0x4

 Section to Segment mapping:
  Segment Sections...
    00
    01     .interp
    02     .interp .note.ABI-tag .hash .dynsym .dynstr .gnu.version .gnu.version_ r .rela.dyn .rela.plt .init .text .fini .rodata .eh_frame_hdr
    03     .data .eh_frame .got2 .dynamic .ctors .dtors .jcr .got .sdata .sbss .p lt .bss
    04     .dynamic
    05     .note.ABI-tag
    06     .eh_frame_hdr
    07

يوضح المثال السابق كيف تظهِر الأداة readelf ربط المقاطع والأقسام في ملف ELF مع الملف الثنائي ‎/bin/ls.

انتقل إلى نهاية الخرج حيث يمكننا أن نرى الأقسام المنقولة إلى المقاطع، فمثلًا يُوضَع القسم ‎.interp في المقطع الذي له الراية INTERP. لاحظ أن الأداة readelf تخبرنا بطلب المفسّر ‎/lib/ld.so.1، وهو الرابط الديناميكي الذي يُشغَّل لإعداد الملف الثنائي للتنفيذ.

يمكننا أن نرى الفرق بين النص والبيانات بالنظر إلى مقطعي LOAD. لاحظ أن المقطع الأول لديه أذونات القراءة والتنفيذ فقط، بينما يكون للمقطع الآخر أذونات القراءة والكتابة والتنفيذ، أي أن مقطع الشيفرة له أذونات القراءة والكتابة (r/w) ومقطع البيانات له أذونات القراءة والكتابة والتنفيذ (r/w/e)، ولكن لا يجب أن تكون البيانات قابلة للتنفيذ. لن يُميَّز قسم البيانات في معظم المعماريات مثل المعمارية x86 الأكثر شيوعًا على أنه يحتوي على قسم بيانات قابل للتنفيذ. لكن المثال السابق مأخوذ من معمارية PowerPC التي لها نموذج برمجة مختلف قليلًا وهو واجهة التطبيق الثنائية Application Binary Interface -أو ABI اختصارًا- التي تتطلب أن يكون قسم البيانات قابلًا للتنفيذ. هذه هي حياة مبرمج الأنظمة، إذ وُضِعت القواعد لكسرها.

تستدعي واجهة ABI في معمارية PowerPC شيفرات اختبارية Stubs للدوال في المكتبات الديناميكية مباشرةً في جدول الإزاحة العام Global Offset Table -أو GOT اختصارًا- بدلًا من جعلها ترتد بين مدخلات منفصلة من جدول PLT، وبالتالي يحتاج المعالج إلى أذونات تنفيذ للقسم GOT الذي يمكنك رؤيته مضمَّنًا في مقطع البيانات.

الشيء الآخر الذي يجب ملاحظته هو أن حجم الملف هو حجم الذاكرة نفسه لمقطع الشيفرة، ولكن حجم الذاكرة أكبر من حجم ملف مقطع البيانات، ويأتي ذلك من القسم BSS الذي يحتوي على متغيرات عامة صفرية.

واجهات ABI

تُعَد واجهة ABI مصطلحًا ستسمع عنه كثيرًا عند العمل مع برمجة الأنظمة، وهو مختلف عن مصطلح API الذي يُعَد واجهات يراها المبرمج في شيفرته البرمجية. تشير ABI إلى واجهات المستوى الأدنى التي يجب أن يتفق عليها المصرِّف ونظام التشغيل والمعالج إلى حد ما للتواصل مع بعضها البعض. سنقدم فيما يلي عددًا من المفاهيم المهمة لفهم واجهات ABI.

ترتيب البايتات

تُرتَّب البايتات باستخدام ترتيب Endianess الذي يحتوي على نوعين هما: Big-endian أي تخزين البتات الأقل أهمية أولًا، و Little-endian أي تخزين البتات الأكثر أهمية أولًا.

العرف المتبع في الاستدعاءات

يمكن تنفيذ الاستدعاءات بطريقتين هما: تمرير المعاملات باستخدام المسجلات registers أو المكدس stack وواصفات الدوال.

بخصوص واصفات الدوال، لا تُستدعَى الدالة في العديد من المعماريات مباشرةً، بل تُستدعَى عبر واصف دالة Function Descriptor. يتكون واصف الدالة في المعمارية IA64 مثلًا من مكونين هما: عنوان الدالة (يُمثَّل بقيمة مقدارها 64 بتًا أو 8 بايتات) وعنوان المؤشر العام Global Pointer أو gp اختصارًا. تحدد واجهة ABI أن المسجل r1 يجب أن يحتوي دائمًا على قيمة المؤشر gp الخاص بالدالة، وهذا يعني أن مهمة المستدعي عند استدعاء دالة هي حفظ قيمة المؤشر gp الخاصة به وضبط المسجل r1 على القيمة الجديدة من واصف الدالة ثم استدعاء هذه الدالة.

تُعَد واصفات الدوال مفيدة للغاية كما سترى لاحقًا. يمكن أن تأخذ تعليمة الجمع add في المعالج IA64 قيمة فورية ذات حجم بحد أقصى 22 بتًا بسبب الطريقة التي يحزُم بها المعالج IA64 التعليمات، حيث تُوضَع ثلاثة تعليمات في كل حزمة، ولا يوجد سوى مساحة كافية للاحتفاظ بقيمة 22 بتًا للحفاظ على الحزمة مع بعضها البعض. القيمة الفورية Immediate Value هي القيمة المحددة مباشرةً وليس القيمة الموجودة في المسجل، إذ تُعَد القيمة 100 في التعليمة add r1 + 100 هي القيمة الفورية.

يمكن أن تتمكن 22 بتًا من تمثيل 4194304 بايت أو 4 ميجابايتات، وبالتالي يمكن إزاحة كل دالة مباشرة في حيّز ذاكرة كبير مقداره 4 ميجابايتات دون الحاجة إلى تحمل عناء تحميل أيّ قيمٍ في المسجل. إذا اتفق المصرِّف والرابط والمحمِّل على ما يشير إليه المؤشر العام كما هو محدد في واجهة ABI، فيمكن تحسين الأداء من خلال تقليل عمليات التحميل.

ترجمة -وبتصرُّف- للأقسام Review of executable files و Representing executable files و ELF و ABIs من فصل Behind the process من كتاب Computer Science from the Bottom Up لصاحبه Ian Wienand.

اقرأ أيضًا

• المقال التالي: مفاهيم متقدمة متعلقة بصيغة ملفات ELF القابلة للتنفيذ
• المقال السابق: تطبيق عملي لبناء برنامج تنفيذي من شيفرة مصدرية بلغة C
• العمليات وعناصرها في نظام تشغيل الحاسوب
• تمثيل الأنواع والأعداد في الأنظمة الحاسوبية

ستتعلم في هذا المقال كيفية إنشاء لعبة حسية تفاعلية، لتخفيف التوتر وتحسين مستوى تركيز الفرد، أو لتوفير وسيلة للتواصل مع الآخرين.

ستعمل في هذا المشروع على:

• توظيف مهاراتك لتصميم وتنفيذ آلة حسية يتفاعل معها المستخدم.
• استخدام عناصر دخل إلكترونية، مثل الأزرار buttons والمقاومات المتغيرة potentiometers للتحكم بعمل عناصر خرج، مثل مصابيح الليد LED والأجراس buzzers.
• تحسين آلتك بناءً على ملاحظات المستخدمين.

معلومة: تدفع الألعاب الحسية المستخدمين على الاستمرار في استخدامها والتفاعل معها، ومنها ألعاب النقر المتكرر fidget toys التي تساعد في تخفيف التوتر وتحسين مستوى تركيز الفرد، وأيضًا الألعاب الحسية التكيُّفية التي توفر وسيلة للأشخاص ذوي الإعاقات الجسدية للتواصل مع الآخرين. قد تحفز الألعاب الحسية جميع الحواس أو تركز فقط على إحداها.

سيعتمد المقال على ملف المشروع codes.zip لذا يمكنك تحميله وبدء العمل.

الدليل الموجز لإنشاء لعبة إلكترونية تفاعلية تحفز الحواس

إليك شرحًا مختصرًا عن أهداف هذا المشروع:

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

معلومة: يُعنى علم الهندسة البشرية Ergonomics بتحسين الطريقة التي يتفاعل فيها البشر مع البيئة المحيطة بهم وإيجاد حلول للمشكلات التي قد تواجههم، وسنحصل عند تطبيقه على أدوات سهلة الاستخدام ومريحة.

متطلبات المشروع

يتطلب المشروع توفر العتاد الآتي:

• لوحة حاسوب راسبيري باي بيكو Raspberry Pi Pico مع أرجل مثبتة عليها.
• كبل USB لنقل البيانات ذو نهايات من النوع USB A و micro USB.
• عناصر إلكترونية وأسلاك توصيل.

أما من ناحية البرمجيات، فلا بد من توفر الآتي:

• برنامج ثوني Thonny: وهو البيئة البرمجية التي سنستخدمها لكتابة الشيفرة بلغة بايثون.

تثبيت برنامج Thonny

سنعرض في الآتي طريقة تثبيت برنامج ثوني Thonny في أنظمة التشغيل المختلفة.

تثبيت برنامج Thonny على نظام تشغيل راسبيري باي

يأتي برنامج ثوني Thonny مثبتًا مع نظام تشغيل راسبيري باي، المعروف سابقًا براسبيان Raspbian، لكن قد تحتاج إلى تحديثه. انقر على الأيقونة في الزاوية العلوية اليسرى من الشاشة لفتح نافذة الطرفية Terminal، أو اضغط المفاتيح التالية معًا Ctrl+Alt+T. ثم اكتب الأمر التالي لتحديث نظام التشغيل وبرنامج Thonny:

sudo apt update && sudo apt upgrade -y

تثبيت برنامج Thonny على أنظمة التشغيل الأخرى

يمكنك تثبيت ثوني Thonny على الحواسيب العاملة بنظام تشغيل لينكس، أو ويندوز، أو ماك، وذلك من الموقع الرسمي thonny.org. انقر على رابط التنزيل الموافق لنظام تشغيل حاسوبك من الزاوية العلوية اليمنى في الموقع، ثم انقر على الملفات بعد تنزيلها، وقد تظهر لك الرسالة التالية على نظام ويندوز:

انقر على خيار المزيد من المعلومات "More info" ثم على التشغيل على أي حال "Run anyway".

التعرف على واجهة برنامج Thonny

عند فتح Thonny ستظهر لك الواجهة التالية:

يمكنك الكتابة بلغة بايثون في النافذة الرئيسية الكبيرة، ثم النقر على زر التشغيل الأخضر Run للتنفيذ، ستظهر لك رسالة لحفظ الملف قبل تشغيله.

اكتب الأمر التالي وشغّله:

print('Hello World!')

تغيير السمة والخط

يمكنك التحكم بلون الخط وحجمه وتغيير السمة المُستخدمة في واجهة البرنامج، وذلك بالنقر على قائمة الأدوات Tools من الشريط أعلى الشاشة، ثم النقر على خيارات Options، ثم انقر بعدها على نافذة الخط والسمة Theme & Font واختر نوع الخط والسمة التي تفضلها من النافذة المنسدلة ثم انقر على زر موافق OK عند الانتهاء.

ننصحك باختيار الخطوط البسيطة الواضحة والابتعاد عن الخطوط المزخرفة أو المشابهة لخط اليد لأنها قد تجعل القراءة أصعب.

إعداد مكتبة picozero

سنعمل في هذه الخطوة على إعداد مكتبة picozero وتوصيل لوحة راسبيري باي بيكو وإعداد برنامج مايكرو بايثون.

أولًا، صِل الطرف الصغير لكبل USB إلى لوحة راسبيري باي والطرف الآخر إلى حاسوبك لتتمكن من برمجة اللوحة عن طريقه.

ثانيًا، افتح محرر Thonny، ولاحظ ما هو الإصدار المستخدم من بايثون بقراءة النص الموجود في الزاوية السفلية اليمنى من الشاشة، انقر على النص واختر "MicroPython (Raspberry Pi Pico)‎"، إذا لم يكن هذا الخيار محددًا. سيطالبك Thonny بتثبيت برنامج MicroPython على حاسوب راسبيري باي بيكو إذا لم تستخدمه مسبقًا، فقط انقر على زر التثبيت Install.

ثالثًا، أضف حزمة بيكو زيرو picozero من خلال النقر على قائمة الأدوات Tools من شريط القوائم في برنامج Thonny، ثم النقر على خيار إدارة الحزم Manage Packages.

ثالثًا، اكتب "picozero"، ثم انقر على زر البحث Search on PyPi.

رابعًا، انقر على picozero من نتائج البحث ثم انقر على زر التثبيت Install.

استلهم أفكارك

اطلع على المشاريع التالية واستلهم منها بعض الأفكار لصنع آلتك التفاعلية:

مشروع الأضواء الليلية

شغّل الفيديو، وشاهد كيف أحدثنا ثقوبًا صغيرةً في ورقة سوداء اللون للحصول على سماء مرصّعة بالنجوم داخل غرفتك. استخدم مصباح الليد متعدد الألوان RGB LED للحصول على تأثير الوميض، واستخدم الأزرار buttons لتشغيل وإطفاء الأضواء. يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع والموجودة باسم "night_sky.py" من ملف المشروع codes.zip.

مشروع النحلة الطنانة

شغّل الفيديو ولاحظ أنه عند الضغط على أجنحة النحلة يصدر صوت طنين، إذ وضعنا ورق قصدير تحت الأجنحة وعند الضغط عليها تلامس قطعةً أخرى من القصدير، وهذا يجعل الجرس يصدر نغمةً ما، إذ يُصدر كل جناح صوتًا مختلفًا؛ كما أضفنا مقاومةً متغيرة للتحكم في مصباح ليد أزرق. يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع والموجودة باسم "The buzzy bee.py" من ملف المشروع codes.zip.

مشروع السيف المضيئ

شغّل الفيديو ولاحظ كيف يضيء نصل السيف عند الضغط على الزر ويصدر الجرس الإلكتروني صوت طنين خافت، وعند تدوير قرص المقاومة المتغيرة يتغير لون النصل وحِدّة الطنين؛ ولإطفاء السيف علينا تدوير قرص المقاومة بالاتجاه المعاكس. يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع والموجودة باسم "saber.py" من ملف المشروع codes.zip.

مشروع الشمعة الإلكترونية

استخدمنا في هذا المشروع مصباح ليد متعدد الألوان RGB LED يضيء باستمرار، وعند النفخ على الشمعة ينطفئ المصباح كما شعلة اللهب الحقيقية؛ حيث يؤدي النفخ إلى تلامس قطعتين من ورق القصدير فتنطفئ الشعلة مدةً قصيرةً، ثم تعود للعمل بعدها. يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع والموجودة باسم "candle.py" من ملف المشروع codes.zip.

إعداد فكرة اللعبة

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

تحديد غرض اللعبة

فكر مليًّا في الهدف من اللعبة التي ستصممها، ما الغرض منها، هل تود تعريف طفل ما على الأصوات والأشكال؟ أم تريدها وسيلةً لتخفيف التوتر عن طريق الضغط على الأزرار وسماع الأصوات الموافقة لكل زر؟ أم تود تصميم أداة لمساعدة الأشخاص على التواصل والتعبير عن احتياجاتهم؟

تحديد الجمهور

فكر مليًا في الجمهور المستهدف من اللعبة، من هم؟ هل تود تصميم اللعبة لتناسب احتياجات صديق ما، أو أحد أفراد العائلة، أو أحد الصفوف الدراسية، أو الأشخاص الذين يمارسون هواية ما؟ كما يمكنك استهداف جمهور أحد الموسيقيين، أو أن تصمم اللعبة لنفسك.

تحديد مميزات اللعبة

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

عليك أخذ النقاط التالية في الحسبان عند التخطيط للعبتك:

• تُشَغّل مكبرات الصوت Speakers كل نغمة على حدى، لذلك ستحتاج لعدة مكبرات صوت لتشغيل عدة نغمات في نفس الوقت.
• توجد رجل تغذية واحدة ذات جهد 3 فولت على لوحة بيكو؛ أي يمكنك استخدام مقاومة متغيرة واحدة، كما أنه يوجد حدٌّ لقيمة التيار الذي توفره لوحة بيكو.

إليك بعض الاقتراحات لعناصر الدخل والخرج التي يمكنك استخدامها معًا:

• مقاومة متغيرة واحدة وجرس إلكتروني واحد.
• أربعة أزرار جاهزة وجرس إلكتروني واحد.
• ثمانية مبدلات يدوية الصنع وجرس إلكتروني واحد.
• مقاومة متغيرة واحدة وجرسان، وزران.
• عدة أزرار وأجراس لعزف عدة نغمات في نفس الوقت.

يمكنك استخدام ما يزيد عن ثمانية عناصر، ولكن عليك حينها استخدام رجل أرضية مشتركة GND.

حدد هل تود استخدام الأزرار ومقاومة متغيرةً كعناصر دخل؟ أم تريد استخدام قواطع يدوية الصنع؟ وهل تريد عزف صوت معين، أم لحنًا ما أو عدة ألحان؟ هل تريد استخدام مصباح ليد ذو لون واحد؟ أم تفضل استخدام المصباح متعدد الألوان؟

اعتماد التصميم الخارجي للعبة

حدد كيف تريد أن يبدو الشكل الخارجي للعبة:

• هل تريد اعتماد تصميم موجود مسبقًا، مثل شكل المكعب أو المفرقعات؟
• هل تفضل اعتماد موضوع برنامجك التلفزيوني أو سلسلتك المفضلة من القصص المصورة، أو حتى أغنيتك المفضلة؟
• هل تريد صنع غلاف خارجي للعبة من صناديق الورق المقوى، أو من القماش، أو البلاستيك؟

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

from picozero import pico_led
from time import sleep

pico_led.on()
sleep(1)
pico_led.off()

تنفيذ اللعبة واختبارها

حان الآن وقت إعداد لعبتك وتنفيذها.

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

إليك تذكرةً ببعض المهارات التي تعلمناها والتي ستفيدك في إنشاء لعبتك:

توصيل عناصر الخرج

استخدام رجل أرضية مشتركة

تحتوي لوحة بيكو على ثمانية أرجل أرضية GND، لذلك لاستخدام ما يزيد عن ثمانية عناصر إلكترونية عليك إعادة استخدام إحدى الأرجل الأرضية، وستحتاج لما يلي:

• سلك توصيل نوع دبوس- مقبس.
• رقائق قصدير، وشريط لاصق ناقل، أو أي مادة ناقلة للتيار الكهربائي.
• شريط لاصق.

أولًا، أنشئ شريطًا من ورق القصدير، أو من أي مادة ناقلة.

ثانيًا، استخدم الشريط اللاصق لتوصيل سلك أحد الأرجل الأرضية مع شريط القصدير، كما يلي:

ثالثًا، صِل القطب الموجب للعنصر الأول مع أحد الأرجل العامة GP على لوحة بيكو، والقطب السالب للعنصر مع شريط القصدير.

رابعًا، لتوصيل المزيد من العناصر، صِل القطب الموجب للعنصر مع إحدى أرجل الأغراض العامة GP، والقطب السالب مع شريط القصدير.

توصيل مصابيح الليد ذات اللون الواحد

لتوصيل مصباح ليد واحد ستحتاج إلى ما يلي:

• لوحة راسبيري باي بيكو.
• مصباح ليد باللون الذي تفضله.
• مقاومة.
• سلكي توصيل نوع مقبس- مقبس.

يجب توصيل مقاومة مع الرجل الموجبة الطويلة لمصباح الليد، وتوصيلها مع الرجل GP13 على لوحة بيكو. وتوصيل الرجل السالبة للمصباح مع أقرب رجل أرضية، كما هو موضح في المخطط التالي:

أما لتوصيل عدة مصابيح ليد ذات اللون الواحد، ستحتاج إلى ما يلي:

• لوحة راسبيري باي بيكو.
• عدة مصابيح ليد باللون الذي تفضله.
• مقاومة لكل مصباح.
• سلكي توصيل نوع مقبس- مقبس لكل مصباح.

يجب توصيل مقاومة مع الرجل الموجبة الطويلة لكل مصباح ليد؛ وتوصيل الرجل الموجبة للمصباح الأول مع الرجل GP13 على لوحة بيكو والسالبة مع أقرب رجل أرضية GND؛ وتوصيل الرجل الموجبة للمصباح الثاني مع الرجل GP8، والسالبة مع أقرب رجل أرضية GND؛ وتوصيل الرجل الموجبة للمصباح الثالث مع الرجل GP5، والسالبة مع أقرب رجل أرضية GND، كما هو موضح في المخطط التالي:

إسناد مصابيح ليد إلى رجل معينة أو عدة أرجل على اللوحة

استخدم الشيفرة التالية لإسناد مصباح وحيد إلى الرجل الموصول معها على لوحة بيكو:

from picozero import LED
led = LED(13)

أما لإسناد عدة مصابيح ليد إلى أرجل لوحة بيكو: استورد تابع المصباح LED من مكتبة picozero، ثم استخدم الشيفرة التالية لإسناد المصابيح إلى الأرجل الموصولة معها على لوحة بيكو:

from picozero import LED
led_1 = LED(13)
led_2 = LED(8)
led_2 = LED(5)

ننصحك بتسمية المتغيرات بأسماء تدل على عملها، كأن تسمّي المصباح المسؤول عن تشغيل المصباح باللون المسؤول عنه، كما يلي:

red_led = LED(13)
green_led = LED(8)
pink_led = LED(5)

إضافة الشيفرة اللازمة لتشغيل مصباح ليد واحد أو عدة مصابيح

إليك الدالة اللازمة لتشغيل المصباح:

def excited(): # دالة تشغل اللون الموافق لمزاجك
    purple.on() # شغّل اللون البنفسجي

أما الشيفرة اللازمة لتشغيل عدة مصابيح فهي على النحو التالي:

def excited(): #  شغّل اللون الموافق لشعورك بالحماس
    purple.on() #  شغّل المصباح البنفسجي
    blue.off() #  أطفئ المصباح الأزرق

def worried(): # شغّل اللون الموافق لشعورك بالقلق
    purple.off() #  أطفئ المصباح البنفسجي
    blue.on() # شغّل المصباح الأزرق

توصيل مصابيح الليد متعددة الألوان

ستحتاج لتوصيل مصباح ليد متعدد الألوان إلى ما يلي:

• لوحة راسبيري باي بيكو.
• مصباح ليد متعدد الألوان ذو مهبط مشترك.
• ثلاث مقاومات.
• أسلاك توصيل نوع مقبس- مقبس (عدد 8).

يجب عليك توصيل مقاومة مع الأرجل الثلاثة الطويلة لمصباح الليد، أما الرجل الطويلة فهي رجل الأرضية ولا تحتاج إلى مقاومة.

معلومة: لاحظ أنه لمصباح الليد متعدد الألوان أربعة أرجل، لذلك أمسك المصباح بحيث تكون الرجل الأرضية هي ثاني رجل من اليسار، وبحيث يصبح ترتيب الأرجل على النحو التالي: الرجل المسؤولة عن اللون الأحمرRed، ثم الرجل الأرضية GND، ثم الرجل المسؤولة عن اللون الأخضرGreen، فالأزرق Blue، وذلك ليسهُل عليك تذكر وظيفة كل رجل.

صِل أرجل مصباح الليد وفقًا لما يلي:

• صِل الرجل المسؤولة عن اللون الأحمرR مع الرجل GP1 على لوحة بيكو.
• صِل الرجل الأرضية GND مع رجل الأرض GND على لوحة بيكو.
• صِل الرجل المسؤولة عن اللون الأخضرG مع الرجل GP2 على لوحة بيكو.
• صِل الرجل المسؤولة عن اللون الأزرق B مع الرجل GP3 على لوحة بيكو.

لإسناد مصباح الليد متعدد الألوان إلى أرجل لوحة بيكو: استورد تابع المصباح متعدد الألوان RGBLED من مكتبة picozero، ثم استخدم الشيفرة التالية لإسناد المصباح إلى الأرجل الموصول معها على لوحة بيكو:

from picozero import RGBLED

rgb = RGBLED(red = 1, green = 2, blue = 3)

استخدم الدالة اللازمة لتشغيل مصباح متعدد الألوان كما هو موضح في الشيفرة التالية:

def happy(): # الشعور بالسعادة
    rgb.color = (0, 255, 0) # شغّل اللون الموافق لشعورك بالسعادة

def sad(): # الشعور بالحزن
    rgb.color = (255, 0, 0) # شغّل اللون الموافق لشعورك بالحزن

تمثيل الألوان بصيغة RGB:

يمكننا تمثيل الألوان بصيغة يفهمها الحاسوب وذلك بالتعبير عن نسبة ما يحتويه اللون من اللون الأحمر والأخضر والأزرق، إذ تخزن هذه القيم في بايت (ثمانية بتات) وتكون قيمتها من 0 إلى 255.

إليك جدولًا يوضح بعض القيم اللونية:

كما يمكنك الاستعانة بمنتقي الألوان من موقع w3schools للحصول على القيم الموافقة للون الذي تريده.

توصيل مكبرات الصوت والأجراس الإلكترونية

ستحتاج لتوصيل جرس إلكتروني واحد مع لوحة بيكو إلى سلكي توصيل نوع مقبس- مقبس. ابدأ بوصل الرجل الطويلة الموجبة للجرس مع الرجل GP5 على لوحة بيكو، وصِل الرجل السالبة مع أقرب رجل تأريض GND.

لمعرفة الرجل الموجبة للجرس، ابحث عن الرجل الأطول، أو عن إشارة الموجب + أعلى الجرس.

وتكون الشيفرة اللازمة لتوصيل جرس واحد على النحو التالي:

from picozero import Speaker

speaker = Speaker(5)

أما لتوصيل جرسين إلكترونيين مع لوحة بيكو لخلق تأثير الصوت المجسم ستحتاج إلى أربعة أسلاك توصيل نوع مقبس- مقبس.

أولًا، صِل الرجل الطويلة الموجبة للجرس الأول مع الرجل GP5 على لوحة بيكو، وصِل الرجل السالبة مع أقرب رجل تأريض GND، ثم صِل الرجل الموجبة للجرس الثاني مع الرجل GP10 على لوحة بيكو، والرجل السالبة مع أقرب رجل تأريض GND.

وتكون الشيفرة اللازمة لتوصيل جرسين على النحو التالي:

from picozero import Speaker

speaker_1 = Speaker(5)
speaker_2 = Speaker(10)

ننصحك بتسمية المتغيرات Variables بأسماء تدل على وظيفتها، مثلًا عند إسناد صوت الطبل للمتغير Speaker_1 فسمّه drum_beat.

ستحتاج لتوصيل السمّاعات مع لوحة بيكو إلى وصلة ذات نهاية بقطر 3 أو 5 مم (وليس وصلة USB)، وثلاثة مشابك تثبيت، وإلى اتباع الخطوات التالية:

1.صِل أحد المشابك مع أحد أرجل الأرض GND القريبة، وصِل المشبكين الآخرين مع الرجل GP5 والرجل GP10، كما هو موضح في الصورة أدناه.

2. صِل نهاية المشبك الأول الموصول مع الرجل GP5، مع نهاية وصلة السمّاعات.
3. صِل نهاية المشبك الثاني الموصول مع الرجل GP10،مع منتصف وصلة السمّاعات.
4. صِل نهاية المشبك الموصول مع رجل الأرض GND مع جذر وصلة السمّاعات.

معلومات مفيدة يجب معرفتها عن الصوت

دعنا نطلع على بعض المعلومات المفيدة عن الأصوات قبل كتابة الشيفرة.

النغمات المتاحة: تُوفر لنا مكتبة picozero ثمان وثمانين علامةً موسيقية، تتبع التدوين الغربي للموسيقا وتشمل جميع العلامات الموجودة في لوحة مفاتيح موسيقية كاملة الحجم.

إليك بعض العلامات المُتاحة:

• b0
• c1
• c#1
• d1
• d#1
• e1
• f1
• f#1

طول النغمة: توجد عدة طرق لتحديد طول النغمة: أولًا، تحديد طول نغمة واحدة باستخدام القيم، إذ يمكنك تحديد مدة النغمة الواحدة بإدخال قيمة في حقل الوسيط الثاني في دالة العزف:

speaker.play(c_note, 0.1) # اعزف النغمة لمدة 0.1 ثانية

ستُعزَف النغمة C في مثالنا لمدة 0.1 ثانية.

ثانيًا، تحديد طول نغمة واحدة باستخدام الثوابت، إذ يمكنك تحديد مدة النغمة الواحدة بالتصريح عن أحد الثوابت في حقل الوسيط الثاني في دالة العزف بدلًا عن القيمة، وتعريف هذا الثابت كما يلي:

BEAT = 1 # BEAT تعريف الثابت

speaker.play(c_note, BEAT) #  اعزف النغمة لمدة ثانية واحدة

لاحظ أنه يمكننا استخدام الثابت BEAT لتحديد طول أي نغمة.

ثالثًا، تحديد طول مجموعة من النغمات باستخدام القيم؛ فعند عزف لحن ما، يُفضل تخزين النغمات وطول كل منها في قائمة list، كما في مثالنا التالي، إذ خزّنا كل نغمة مع طولها في قائمة، وجمعنا النغمات الثلاث في قائمة:

my_tune = [ ['d5', 1], ['d#5', 0.5], ['f5', 1.2]] # قائمة بالنغمات وطول كل منها

احرص على كتابة النغمة ضمن علامتي اقتباس ' '.

رابعًا، تحديد طول مجموعة من النغمات باستخدام الثوابت: ابدأ أولًا بتحديد طول النغمة الذي تريده باستخدام الثابت BEAT، اخترنا في مثالنا القيمة 0.4، ثم صرّح عن النغمات التي تود عزفها في قائمة ضمن علامتي ' ' واستخدم الثابت BEAT لتحديد طول النغمات:

BEAT = 0.4 # طول النغمة الواحدة

my_tune = [ ['d5', BEAT], ['d#5', BEAT / 2], ['f5', BEAT * 1.5]] # قائمة بالنغمات وطول كل منها

يمكنك التحكم بعدد النغمات في الدقيقة BPM عن طريق تقسيم الثابت BEAT على عدد ما للحصول على نغمات أقصر، مثلًا 2 / BEAT، أو مضاعفته بضربه بعدد ما للحصول على نغمات أطول، مثلًا BEAT * 1.5

• استخدام الأرقام عوضا عن النغمات: يمكنك الاستعاضة عن النغمات باستخدام قيم الترددات الموافقة لها، والتي تتراوح بين القيمة 150 إلى 10000، إليك المثال التالي لعزف نغمة ذات التردد 523 لثانية واحدة:

speaker.play(523, 1) # اعزف النغمة ذات التردد 523 لثانية واحدة

• تحويل المقطوعات الموسيقية إلى نغمات: تُتيح لنا مكتبة "picozero" عزف المقطوعات الموسيقية الشهيرة واستخدامها في مشاريعنا، إذ تُستخدم الأحرف الإنجليزية للتعبير عن العلامات الموسيقية، وتستخدم الأرقام للتعبير عن موقع العلامة في السلم الموسيقي الكبير.

على سبيل المثال، توجد العلامة C الوسطى في منتصف السلم الموسيقي ويعبر عنها بالرمز C4، وتزداد الأرقام المعبرة عن العلامة كلما صعدنا في السلم الكبير، وتنقص عند النزول.

تحتوي المقطوعة الموسيقية علامات حادة يُعَبر عنها بالرمز # وتدعى "دييز". في مثالنا أدناه، توجد عدة علامات موسيقية حادة، أولها العلامة C الحادة والتي يرمز لها c#4.

وقد تحتوي المقطوعة الموسيقية على علامات بسيطة يُشار إليها بالرمز ♭ وتدعى "بيمول"، لكن سنشير إليها في مشروعنا بالرمز # لعدم احتواء مكتبة picozero على شيفرة خاصة للتعبير عن العلامات البسيطة، وعلينا النزول نصف درجة في السلم الموسيقي للتحويل من علامة بسيطة إلى حادة.

إليك الأمثلة التالية:

• تتحوّل العلامة البسيطة D إلى C حادة أو c#4.
• تتحوّل العلامة البسيطة E إلى D حادة أو d#4.
• تتحوّل العلامة البسيطة G إلى F حادة أو f#4.
• تتحوّل العلامة البسيطة A إلى G حادة أو g#4.

أمثلة عن بعض الشيفرات الموسيقية

الشيفرة اللازمة لعزف علامة موسيقية واحدة

إليك مثالًا عن الشيفرة اللازمة لعزف العلامة C الوسطى لمدة نصف ثانية:

def c_note():
    speaker.play('c4', 0.5) # اعزف العلامة لمدة نصف ثانية

الشيفرة اللازمة لعزف لحن موسيقي

خزّن النغمات وطول كل منها في قائمة للحصول على لحن ما ، ثم شغّل اللحن باستخدام الدالة play:

BEAT = 0.4

liten_mus = [ ['d5', BEAT / 2], ['d#5', BEAT / 2], ['f5', BEAT], ['d6', BEAT], ['a#5', BEAT], ['d5', BEAT],
              ['f5', BEAT], ['d#5', BEAT], ['d#5', BEAT], ['c5', BEAT / 2],['d5', BEAT / 2], ['d#5', BEAT],
              ['c6', BEAT], ['a5', BEAT], ['d5', BEAT], ['g5', BEAT], ['f5', BEAT], ['f5', BEAT], ['d5', BEAT / 2],
              ['d#5', BEAT / 2], ['f5', BEAT], ['g5', BEAT], ['a5', BEAT], ['a#5', BEAT], ['a5', BEAT], ['g5', BEAT],
              ['g5', BEAT], ['', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT / 2], ['d6', BEAT / 2], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT / 2], ['g5', BEAT / 2], ['a5', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT],
              ['f5', BEAT], ['f5', BEAT], ['f5', BEAT / 2], ['d#5', BEAT / 2], ['d5', BEAT], ['f5', BEAT], ['d6', BEAT],
              ['d6', BEAT / 2], ['c6', BEAT / 2], ['b5', BEAT], ['g5', BEAT], ['g5', BEAT], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT], ['f5', BEAT], ['d6', BEAT], ['a5', BEAT], ['a#5', BEAT * 1.5] ]

def play_liten_mus():
    speaker.play(liten_mus)

الشيفرة اللازمة لتوليد تأثيرات صوتية مختلفة باستخدام الترددات

يمكننا توليد تأثيرات صوتية ممتعة، أو مزعجة، وذلك بعزف نغمات قصيرة ذات ترددات مختلفة، إذ أنه كلما تغير التردد تختلف العلامة الموسيقية التي نسمعها وتختلف نغمتها.

إليك الشيفرة التالية التي ترتفع فيها الترددات تدريجيًا لخلق صوت مبهج:

def win(): # ترددات متزايدة
    for i in range(2000, 5000, 100):
        speaker.play(i, 0.05) # اعزف النغمة لمدة قصيرة جدًا

أما المثال التالي فخفضنا فيه الترددات تدريجيًا لتوليد صوت زقزقة العصافير:

def chirp(): # توليد صوت زقزقة العصافير
    for _ in range(2): # ترددات متناقصة
        for i in range(5000, 2999, -100):
            speaker.play(i, 0.02) # اعزف النغمة لمدة قصيرة جدًا
        sleep(0.2)

غَيّر الترددات المستخدمة في حلقة التكرار for واستخدم الترددات ضمن المجال من 150 إلى 10000.

الشيفرة اللازمة لتوليد ضجيج أبيض من صوت قرع الطبل

إليك الشيفرة التالية:

from picozero import Speaker
from time import sleep
from random import randint

speaker = Speaker(5)

for i in range(100):
    speaker.play(randint(500, 5000), duration=None)
    sleep(0.001)
    speaker.stop()
    sleep(0.5)

الشيفرة اللازمة لعزف النغمات بصورة متكررة

أنشئ قائمةً بالنغمات التي تريد عزفها وطول كل منها للحصول على لحن ما، ثم استخدم حلقة تكرار for لتشغيل اللحن نغمةً نغمة، أو علامةً علامة باستخدام الدالة play:

BEAT = 0.4

liten_mus = [ ['d5', BEAT / 2], ['d#5', BEAT / 2], ['f5', BEAT], ['d6', BEAT], ['a#5', BEAT], ['d5', BEAT],
              ['f5', BEAT], ['d#5', BEAT], ['d#5', BEAT], ['c5', BEAT / 2],['d5', BEAT / 2], ['d#5', BEAT],
              ['c6', BEAT], ['a5', BEAT], ['d5', BEAT], ['g5', BEAT], ['f5', BEAT], ['f5', BEAT], ['d5', BEAT / 2],
              ['d#5', BEAT / 2], ['f5', BEAT], ['g5', BEAT], ['a5', BEAT], ['a#5', BEAT], ['a5', BEAT], ['g5', BEAT],
              ['g5', BEAT], ['', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT / 2], ['d6', BEAT / 2], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT / 2], ['g5', BEAT / 2], ['a5', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT],
              ['f5', BEAT], ['f5', BEAT], ['f5', BEAT / 2], ['d#5', BEAT / 2], ['d5', BEAT], ['f5', BEAT], ['d6', BEAT],
              ['d6', BEAT / 2], ['c6', BEAT / 2], ['b5', BEAT], ['g5', BEAT], ['g5', BEAT], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT], ['f5', BEAT], ['d6', BEAT], ['a5', BEAT], ['a#5', BEAT * 1.5] ]

for note in liten_mus:
    speaker.play(note)

الشيفرة اللازمة لعزف عدة نغمات متزامنة

إذا أردت عزف لحن ما مثلًا، وتشغيل لحن أو تأثير صوتي آخر بالتزامن معه، فيمكنك ذلك بوضع wait=False في حقل الوسيط الثاني للدالة play .

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

BEAT = 0.4

liten_mus = [ ['d5', BEAT / 2], ['d#5', BEAT / 2], ['f5', BEAT], ['d6', BEAT], ['a#5', BEAT], ['d5', BEAT],
              ['f5', BEAT], ['d#5', BEAT], ['d#5', BEAT], ['c5', BEAT / 2],['d5', BEAT / 2], ['d#5', BEAT],
              ['c6', BEAT], ['a5', BEAT], ['d5', BEAT], ['g5', BEAT], ['f5', BEAT], ['f5', BEAT], ['d5', BEAT / 2],
              ['d#5', BEAT / 2], ['f5', BEAT], ['g5', BEAT], ['a5', BEAT], ['a#5', BEAT], ['a5', BEAT], ['g5', BEAT],
              ['g5', BEAT], ['', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT / 2], ['d6', BEAT / 2], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT / 2], ['g5', BEAT / 2], ['a5', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT],
              ['f5', BEAT], ['f5', BEAT], ['f5', BEAT / 2], ['d#5', BEAT / 2], ['d5', BEAT], ['f5', BEAT], ['d6', BEAT],
              ['d6', BEAT / 2], ['c6', BEAT / 2], ['b5', BEAT], ['g5', BEAT], ['g5', BEAT], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT], ['f5', BEAT], ['d6', BEAT], ['a5', BEAT], ['a#5', BEAT * 1.5] ]

sound = [ [523, 0.1], [None, 0.1], [523, 0.4] ]

def annoying_sound():
    speaker2.play(sound, wait=False) # شغّل بالتزامن مع اللحن الأول

button.when_pressed = annoying_sound

try:
    speaker.play(liten_mus)
finally:
    speaker.off() #أطفئ مكبر الصوت الأول عند إيقاف البرنامج
    speaker2.off() # أطفئ مكبر الصوت الثاني عند إيقاف البرنامج

توصيل عناصر الدخل

توصيل الأزرار مع لوحة بيكو

ستحتاج لتوصيل زر واحد مع لوحة بيكو إلى ما يلي:

• لوحة راسبيري بيكو.
• زر إلكتروني.
• سلكي توصيل نوع مقبس-مقبس.

صِل سلكي التوصيل مع أرجل الزر واستخدم الشريط اللاصق لتثبيتهما إن لزم الأمر، ثم صِل أحد السلكين مع الرجل GP18 والسلك الآخر مع أقرب رجل أرضية، لا يهمنا ترتيب توصيل الأسلاك إذ إنه لا توجد قطبية للزر.

لتوصيل عدة أزرار إلكترونية مع لوحة بيكو ستحتاج إلى ما يلي:

• لوحة راسبيري بيكو.
• أزرار إلكترونية.
• سلكي توصيل نوع دبوس-مقبس لكل زر.

توضح الصورة التالية طريقة توصيل ثلاثة أزرار مع لوحة بيكو، وإذا أردت توصيل زر رابع فما عليك سوى توصيله مع إحدى أرجل الأغراض العامة GP ورجل أرضية.

استخدم سلكي توصيل نوع دبوس- مقبس لتوصيل الزر الأول مع الرجل GP18 ومع أقرب رجل أرضية GND، ثم صِل الزر الثاني مع الرجل GP22، والثالث مع الرجل GP28 بنفس الطريقة.

• استيراد تابع الزر Button من مكتبة picozero: إليك الشيفرة اللازمة لاستيراد تابع الزر Button من مكتبة picozero:

from picozero import Button

• الشيفرة اللازمة لتوصيل زر إلكتروني واحد: لتوصيل زر إلكتروني علينا إسناده إلى الرجل الموصول معها على لوحة بيكو، كما يلي:

from picozero import Button

button = Button(18)

• الشيفرة اللازمة لتوصيل عدة أزرار إلكترونية: استورد تابع الزر Button من مكتبة picozero، ثم استخدم الشيفرة التالية لإسناد عدة أزرار إلى الأرجل الموصولة معها على لوحة بيكو:

from picozero import Button

button_1 = Button(18)
button_2 = Button(22)
button_3 = Button(28)

ننصحك بتسمية المتغيرات بأسماء تدل على عملها، كأن تسمّي الزر المسؤول عن تشغيل المصباح الأحمر red_button أو أي اسم آخر تراه مناسبًا.

• تشغيل نغمة معينة عند الضغط على كل زر: يمكنك إضافة عدة أزرار يستدعي كل منها دالة صوتية مختلفة عند الضغط عليها، وذلك باستدعاء الدالة الموافقة عند الضغط على الزر عن طريق ذكر اسمها بدون استخدام الأقواس. كما في المثال التالي:

happy_button.when_pressed = happy
sad_button.when_pressed = sad
angry_button.when_pressed = angry

• تشغيل النغمة التالية عند الضغط على الزر: عرّف متغيرًا ما، وليكن option، لتخزين النغمة الحالية فيه واستدعاء الدالة التالية، واحرص على مطابقة أسماء الدوال في الشيفرة للدوال التي استخدمتها في الفقرة السابقة:

option = 0 # خزّن النغمة الحالية في هذا المتغير

def choice(): # استدعي الدالة الصوتية التالية وعدّل قيمة متغير التخزين
    global option
    if option == 0:
        energised() # دالة النغمة الأولى
    elif option == 1:
        calm() # دالة النغمة الثانية
    elif option == 2:
        focused() # دالة النغمة الثالثة
    elif option == 3:
        rgb.off()

    # انتقل إلى الخيار الثاني
    if option == 3:
        option = 0
    else:
        option = option + 1

button.when_pressed = choice # استدعي الدالة التالية عند الضغط على الزر

توصيل المبدل مع لوحة بيكو والشيفرة اللازمة لذلك

• توصيل مبدل يدوي الصنع أو زر مع لوحة بيكو: ستحتاج إلى سلكي توصيل نوع دبوس-مقبس. صِل أحدهما مع الرجل GP18 والسلك الآخر مع أقرب رجل أرضية، كما يلي:

ثم يمكنك صنع مبدّل يدوي، كما تعلمنا في مشروع سابق، وتوصيلها مع اللوحة وذلك بتوصيل النهاية الحرة للأسلاك مع الجزء الناقل من المبدّل، مثل النحاس أو ورق القصدير.

• توصيل عدة قواطع يدوية أو أزرار مع لوحة بيكو: ستحتاج إلى سلكي توصيل نوع دبوس-مقبس لكل قاطعة تود توصيلها مع لوحة بيكو.

استخدم سلكي توصيل نوع دبوس- مقبس لتوصيل المبدّل الأول مع الرجل GP18 ومع أقرب رجل أرضية GND، ثم صِل المبدّل الثاني مع الرجل GP22 ومع أقرب رجل أرضية، والثالث مع الرجل GP28 ورجل الأرضية بنفس الطريقة، كما هو موضح في المخطط التالي:

لكتابة الشيفرة اللازمة لتوصيل المبدّل لا بُد من استيراد تابع المبدل Switch من مكتبة picozero كما هو موضح في الشيفرة التالية:

from picozero import Switch

استورد تابع المبدّل Switch من مكتبة picozero، ثم استخدم الشيفرة التالية لإسناد المبدّل إلى الرجل الموصولة معه على لوحة بيكو:

from picozero import Switch

switch = Switch(18)

ولتوصيل عدة مبدّلات: استورد تابع المبدّل Switch من مكتبة picozero، ثم استخدم الشيفرة التالية لإسناد عدة مبدّلات إلى الأرجل الموصولة معها على لوحة بيكو:

from picozero import Switch

switch_1 = Switch(18)
switch_2 = Switch(22)
switch_3 = Switch(28)

ننصحك بتسمية المتغيرات بأسماء تدل على عملها، كأن تسمّي القاطعة المسؤولة عن تشغيل المصباح الأحمر red_switch أو أي اسم آخر تراه مناسبًا.

توصيل المقاومات المتغيرة مع لوحة بيكو

ستحتاج لتوصيل مقاومة متغيرة مع اللوحة إلى ما يلي:

• لوحة راسبيري بيكو.
• مقاومة متغيرة.
• أسلاك توصيل نوع مقبس-مقبس (عدد 3).

توجد للمقاومة المتغيرة ثلاثة أرجل: رجل الأرضية GND، ورجل تشابهية Analogue، ورجل التغذية 3V3، وعند تدوير قرص المقاومة المتغيرة إلى أقصى اليسار سيشير السهم إلى الرجل الأرضية GND، وعند تدويره إلى أقصى اليمين سيشير السهم إلى رجل التغذية 3V3، أما الرجل الوسطى للمقاومة فهي الرجل التشابهية التي تستمد منها لوحة بيكو القيم لقراءتها.

• صِل سلك توصيل ذو نهايات مقبس-مقبس مع كل من أرجل المقاومة الثلاث، ثبت التوصيلات بالشريط اللاصق إن لزم الأمر.
• صِل النهاية الحرة للسلك الموصول مع رجل المقاومة ذات الرقم 1 مع رجل الأرض GND الموجودة بين الرجلين GP21 وGP22.
• صِل رجل المقاومة الوسطى مع الرجل GP26_A0 على لوحة بيكو.
• صِل رجل المقاومة ذات الرقم 3 مع رجل التغذية 3V3.

• استيراد تابع المقاومة المتغيرة Pot من مكتبة picozero: إليك الشيفرة اللازمة لاستيراد تابع المقاومة المتغيرة Pot من مكتبة picozero:

from picozero import Pot

وتكون الشيفرة اللازمة لتوصيل مقاومة متغيرة على النحو التالي:

from picozero import Pot

dial = Pot(0) # Connected to pin A0 (GP_26)

عند استخدام مقاومة متغيرة للتحكم في الخرج، سنحتاج إلى تقسيم قيم المقاومة إلى أجزاء متساوية. كأن نستخدم التابع dial.value للحصول على قيم تتراوح بين 0 و 1، كما يمكننا ضرب القيمة ب 100 للحصول على نسبة مئوية؛ فإذا كان لديك خمس قيم يمكنك التحقق ما إذا كانت القيمة أقل من 20 أو 40 أو 60 أو 80 أو 100؛ أما إذا كان لديك ثلاث قيم يمكنك تقسيم القراءات للتحقق ما إذا كانت القيمة أقل من 33 أو 66 أو 100.

إليك المثال التالي:

while True:
    mood = dial.value * 100 # تحويل إلى نسبة مئوية
    print(mood)
    if mood < 20:
        happy()
    elif mood < 40:
        good()
    elif mood < 60:
        okay()
    elif mood < 80:
        unsure()
    else:
        unhappy()
    sleep(0.1)

الآن، شغّل دارتك وتحقق أن جميع عناصر الدخل والخرج تعمل كما يجب، واستعن بفقرة تصحيح الأخطاء أدناه إذا واجهتك أي مشكلة.

تصميم الهيكل الخارجي

تثبيت العناصر داخل الورق المقوى أو البلاستيك

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

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

استخدم الشريط اللاصق لتثبيت العناصر في مكانها.

تبديد الضوء المنبعث من مصباح الليد

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

كما يمكنك توجيه الضوء في اتجاه معين باستخدام ورقة بيضاء، وذلك لتحصل على أكبر قدر ممكن من الضوء.

تثبيت أسلاك التوصيل باستخدام الشريط اللاصق

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

استخدام سكين الحرف

تُعد سكاكين الحرف Crafts مفيدةً عند صنع الحرف اليدوية، لكن يجب أن تكون حذرًا جدًا عند استخدامها لأنها حادة جدًا ويمكن أن تسبب جروحًا وإصابات. احرص على وجود شخص بالغ عند استخدامك للسكاكين، أو اطلب منه استخدامها عوضًا عنك، كما ننصحك باستخدام لوح القص لحماية الأسطح، أو باستخدام لوح التقطيع الخشبي المتوفر في كل المطابخ.

توصيل الأسلاك ببعضها

قد تحتاج إلى أسلاك توصيل طويلة جدًا لتوصيل مصابيح الليد مع أرجل لوحة بيكو، أو يمكنك وصل الأسلاك ببعضها للحصول على سلك طويل، وذلك عبر توصيل سلك ذو نهايات دبوس-مقبس مع سلك ذو نهايات مقبس-مقبس للحصول على سلك مقبس-مقبس طويل جدًا، ويُطلق على هذه الطريقة اسم سلسلة الأقحوان daisy chaining.

ننصحك باستخدام سلكين لهما اللون نفسه ليسهل تتبع السلك ومعرفة العنصر الموصول معه.

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

إنشاء مبدل فوري يعمل عند الإسقاط

ستحتاج لإنشاء مبدّل فوري Drop switch ما يلي:

• لوحة راسبيري بيكو.
• سلكي توصيل نوع دبوس-مقبس.
• ورق قصدير.
• شريط لاصق.

أولًا، أنشئ شريطين من ورق القصدير، أو من أي مادة ناقلة.

ثانيًا، ثبت سلكي التوصيل مع شريطي القصدير باستخدام الشريط اللاصق، كما يلي:

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

رابعًا، صِل النهايات الحرة للسلكين مع لوحة بيكو وأسقط المجسم لإغلاق المبدّل.

إنشاء قاطعة يدوية تعمل عند السحب

إليك ما سنحتاج إليه:

• مقص.
• ورق مقوى.
• رقائق القصدير.
• غراء وشريط لاصق.
• شرائط ملونة وورق ملون.
• قلم رصاص ومسطرة (اختياري).

أولًا، قُصَّ الورق المقوى إلى ثلاثة مستطيلات متساوية الحجم.

ثانيًا، قُصَّ مستطيلًا صغيرًا في منتصف المستطيل الأول، واحتفظ به لاستخدامه لاحقًا.

ثالثًا، قُصَّ قطعًا من ورق القصدير بحجم المستطيلات الكبيرة، ثم الصقها عليها باستخدام الغراء، واحرص على عدم وضع الغراء على الوجه الخارجي لورق القصدير حتى لا تتأثر التوصيلات لاحقًا.

رابعًا، قُصَّ أطراف المستطيل الصغير للحصول على شكل مدبب أو بشكل حرف V، ثم قلّم الأطراف بمقدار بضع ملميترات كي يتسع المستطيل الصغير في الفتحة.

خامسًا، غلّف المستطيل الصغير بكامله بورق القصدير، واحرص على استخدام ورقة قصدير واحدة، إذ ستسمح هذه القطعة بمرور التيار عند إغلاق المبدّل.

سادسًا، استخدم الشريط اللاصق لتثبيت على الوجه العلوي للمستطيلات.

احرص على أن يكون الدبوس المعدني للسلك ملامسًا لورق القصدير، وأن يكون الجزء البلاستيكي الأسود ملامسًا لحافة المستطيل.

سابعًا، أضف مزيدًا من الشريط اللاصق لتثبيت السلك ومنع انفكاكه عن طريق الخطأ.

ثامنًا، ادهن بعض الغراء على المستطيل الذي فرّغنا منتصفه (الموجود في يسار الصورة) والصقه مع المستطيل المغطى بالقصدير (يمين الصورة)، واحرص على ألا تتلامس طبقتي القصدير الموجودة على حواف المستطيلات، قُصّها إذا لزم الأمر:

أصبح المبدّل جاهزًا للاستخدام في مشروعك.

تثبيت الأسلاك والعناصر باستخدام الشريط اللاصق

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

أخيرًا، اختبر المشروع بعد انتهائك من تنفيذ التصميم الخارجي، واعرضه على أفراد العائلة أو الأصدقاء للحصول على ملاحظاتهم، وقرر هل تود إجراء أي تعديل؟

تصحيح الأخطاء

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

التحقق من سلامة لوحة بيكو باستخدام مصباح الليد

استخدم مصباح الليد الموجود على لوحة بيكو للتحقق من سلامة اللوحة، وذلك بجعل المصباح يومض عند تشغيل الشيفرة بإضافة الشيفرة التالية في البداية:

from picozero import pico_led
from time import sleep

pico_led.on()
sleep(2)
pico_led.off()

تصحيح الأخطاء الموجودة في الشيفرة

• تحقق من وجود أي رسائل خطأ في نافذة صدفة Thonny وتحقق من محتواها، إن وجدت.
• راجع الشيفرة التي كتبتها وتحقق من خلوها من الأخطاء، مثل نسيان علامة : مثلًا، أو وجود مسافة بادئة دون الحاجة لها.
• تأكد من استيراد توابع العناصر التي ستستخدمها في مشروعك من مكتبة picozero مثل تابع مصباح الليد RGBLED أو الزر Button.
• استخدم تعليمة الطباعة print لإضافة شرح مختصر عند كل خطوة، مثل (البدء)print أو (ضبط المصباح على اللون الأخضر)print.

لا تعمل بعض العناصر الإلكترونية كما يجب

• تأكد أن جميع العناصر متصلة ببعضها جيدًا، وتحقق من ثبات نقاط توصيل الأسلاك مع اللوحة ومع العناصر.
• تأكد أن أرقام الأرجل المستخدمة في الشيفرة مطابقة لأرقام الأرجل الموصولة مع مصباح الليد، وتأكد من إعادة وصل الأرجل في حال فصلتها عند العمل على تصميم شكل الآلة الموسيقية.
• تحقق من وصل العناصر وفق القطبية الصحيحة، إذ قد تحتوي بعض العناصر على قطب موجب + وآخر سالب -.
• في حال تحققت من جميع النقاط السابقة ولا زالت آلتك لا تعمل، فجرّب تبديل العناصر الإلكترونية بأخرى جديدة.

لا يحدث شيء عند تشغيل الشيفرة

• تأكد أن جميع العناصر متصلة ببعضها جيدًا، وأنها موصولة مع الأرجل الصحيحة على اللوحة.
• تحقق من صدفة Thonny عند تشغيل الشيفرة؛ لربما نسيت نسيت تعريف بعض الدوال أو المتغيرات، أو قد تكون نسيت تعديل الشيفرة لتتناسب مع مشروعك.
• تحقق من صحة الشيفرة التي كتبتها، واستخدم تابع الطباعة print لإيضاح عمل الشيفرة.
• تحقق أنك استدعيت الدوال في الشيفرة.

إليك مثالًا عن طريقة استدعاء الدالة، إذا عرفنا الدالة happy أولًا، ثم استدعيناها عن طريق التصريح عن اسمها (بدون وسطاء داخل الأقواس):

def happy(): # الدالة الأولى
    rgb.color = (0, 255, 0) # اللون الموافق للدالة الأولى

def sad(): # الدالة الثانية
    rgb.color = (255, 0, 0) # اللون الموافق للدالة الثانية

happy()

لا يضيء مصباح الليد عند استدعاء الدالة المسؤولة عن تشغيله

تأكد من مطابقة الأرجل الموصول معها المصباح على لوحة بيكو للأرجل المسند إليها في الشيفرة.

لا يضيء مصباح الليد باللون الصحيح

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

لا تصدر النغمات أو أن صوتها مختلف عن الصوت المطلوب

من غير المرجح أن تكون المشكلة في الشيفرة التي كتبتها، بما أنها كانت سليمةً قبل تنفيذ التصميم الخارجي للعبة، لذا عليك التحقق من التوصيلات والعناصر.

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

وذلك للمشاكل الآتية:

• يتأخر عزف النغمة عند الضغط على زر ما: عند استخدام أحد الأحداث events مثل حدث الضغط when_pressed لتشغيل دالة ما، فإن هذه الدالة ستُنفَذ حتى انتهائها وستمنع تشغيل أي شيء آخر في الشيفرة.

sound = [ [523, 0.1], [None, 0.1], [523, 0.4] ]

def annoying_sound():
    speaker.play(sound, wait=False) # لا تؤخر تشغيل الشيفرة

button.when_pressed = annoying_sound

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

حاول حل المشاكل الأخرى التي قد تواجهك عند التنفيذ وشاركنا طريقة الحل في منصة حسوب IO أو في أكاديمية حسوب.

ترقية المشروع

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

استخدمنا في النسخة الأصلية لمشروع الأضواء الليلية مصباح ليد متعدد الألوان وأحدثنا ثقوبًا صغيرةً في ورقة ليخرج منها الضوء ونحصل على تأثير مشابه لسماء مرصّعة بالنجوم، وأضفنا زرًا تشغيل وإطفاء المصباح.

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

الخاتمة

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

إذا واجهت مشاكلًا عند تنفيذ هذا المشروع فيمكنك الحصول على الدعم والمساعدة عبر إضافة سؤالك في قسم الأسئلة والأجوبة في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال Sensory gadget من الموقع الرسمي لراسبيري باي.

اقرأ أيضًا

• تصميم وتنفيذ آلة موسيقية باستخدام لوحة راسبيري باي بيكو
• صنع جهاز لعرض الحالة المزاجية باستخدام لوحة راسبيري باي بيكو
• صنع قلب نابض باستخدام لوحة راسبيري باي بيكو

سنعمل في هذا المشروع على إنشاء آلة تصدر أصواتًا وموسيقى مختلفة باستخدام الأزرار buttons، والمبدّلات الإلكترونية switches، والمقاومات المتغيرة potentiometer.

لنحصل على آلة مشابهة لما يلي:

اصنع لوحة تصدر تأثيراتٍ صوتيةً مختلفةً عند الضغط عليها، وذلك باستخدام الورق المقوى ورقائق القصدير، ويمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع من ملف codes.zip.

ستتعلم في هذا المشروع ما يلي:

• كيفية تصميم جهاز صوتي يعمل وفق غرضٍ معين.
• برمجة الجرس الإلكتروني buzzer لتشغيل تأثيرات صوتية وموسيقى.
• إنشاء واجهة تتيح للمستخدم التحكم بالأصوات.

معلومة: تملك الأصوات تأثيرًا على حالتنا النفسية، فقد تكون مهدئةً، أو مزعجةً، أو منشِطة، فعلى سبيل المثال، يجد بعض الأطفال الرُضع لآلة الضجيج الأبيض Whitenoise تأثيرًا مهدئًا يساعدهم على الاسترخاء والنوم؛ بينما يستخدم منسقو الأغاني DJs أجهزةً محمولة لتوليد النغمات، ويستخدم محبو الدُعابة أجهزةً تصدر تأثيرات صوتية لإضحاك الناس. ماذا عنك؟ هل توجد آلة صوتية تستخدمها يوميًا؟

متطلبات المشروع

عتاد:

1. لوحة حاسوب راسبيري باي بيكو Raspberry Pi Pico مع أرجل مثبتة عليها.
2. كبل USB لنقل البيانات ذو نهايات من النوع USB A و micro USB.
3. مقاومات متغيرة potentiometer وأزرار buttons.
4. جرس إلكتروني غير فعّال passive.
5. أسلاك توصيل.
6. بعض مستلزمات الأشغال اليدوية، مثل الورق المقوى، ورقائق القصدير، وشريط لاصق.
7. مصباح ليد عادي أو متعدد الألوان RGB LED ذو مهبط مشترك common cathode، ومقاومات وأسلاك توصيل. (اختياري)
8. جرس إلكتروني إضافي غير فعّال لخلق تأثير الصوت المجسم stereo. (اختياري)

برمجيات

1. برنامج ثوني Thonny: وهو البيئة البرمجية التي سنستخدمها لكتابة الشيفرة بلغة بايثون.

تثبيت برنامج ثوني على نظام تشغيل راسبيري باي

يأتي برنامج ثوني مثبتًا مع نظام تشغيل راسبيري باي، المعروف سابقًا براسبيان Raspbian، لكن قد تحتاج إلى تحديثه. انقر على الأيقونة في الزاوية العلوية اليسرى من الشاشة لفتح نافذة الطرفية Terminal، أو اضغط المفاتيح التالية معًا Ctrl+Alt+T. ثم اكتب الأمر التالي لتحديث نظام التشغيل وبرنامج ثوني:

sudo apt update && sudo apt upgrade -y

تثبيت برنامج ثوني على أنظمة التشغيل الأخرى

يمكنك تثبيت ثوني على الحواسيب العاملة بنظام تشغيل لينكس، أو ويندوز، أو ماك، وذلك من الموقع الرسمي thonny.org انقر على رابط التنزيل الموافق لنظام تشغيل حاسوبك من الزاوية العلوية اليمنى في الموقع، ثم انقر على الملفات بعد تنزيلها، قد تظهر لك الرسالة التالية على نظام ويندوز:

انقر على خيار المزيد من المعلومات "More info" ثم على التشغيل على أي حال "Run anyway".

التعرف على واجهة برنامج ثوني

ستظهر لك الواجهة التالية عند فتح ثوني:

يمكنك الكتابة بلغة بايثون في النافذة الرئيسية الكبيرة، ثم النقر على زر التشغيل الأخضر Run للتنفيذ، ستظهر لك رسالة لحفظ الملف قبل تشغيله.

اكتب الأمر التالي وشغّله:

print('Hello World!')

تغيير السمة والخط

يمكنك التحكم بلون الخط وحجمه وتغيير السمة المُستخدمة في واجهة البرنامج، وذلك بالنقر على قائمة الأدوات Tools من الشريط أعلى الشاشة، ثم النقر على خيارات Options، ثم انقر بعدها على نافذة الخط والسمة Theme & Font واختر نوع الخط والسمة التي تفضلها من النافذة المنسدلة ثم انقر على زر موافق OK عند الانتهاء.

ننصحك باختيار الخطوط البسيطة الواضحة والابتعاد عن الخطوط المزخرفة أو المشابهة لخط اليد لأنه قد تجعل القراءة أصعب.

إعداد مكتبة picozero

سنعمل في هذه الخطوة على إعداد مكتبة picozero وتوصيل لوحة راسبيري باي بيكو وإعداد برنامج مايكرو بايثون.

أولًا، صِل الطرف الصغير لكبل USB إلى لوحة راسبيري باي والطرف الآخر إلى حاسوبك لتتمكن من برمجة اللوحة عن طريقه.

ثانيًا، افتح محرر ثوني، ولاحظ ما هو الإصدار المستخدم من بايثون بقراءة النص الموجود في الزاوية السفلية اليمنى من الشاشة، انقر على النص واختر "MicroPython (Raspberry Pi Pico)‎"، إذا لم يكن هذا الخيار محددًا. سيطالبك ثوني بتثبيت برنامج MicroPython على حاسوب راسبيري باي بيكو إذا لم تستخدمه مسبقًا، فقط انقر على زر التثبيت Install.

ثالثًا، أضف حزمة بيكو زيرو picozero من خلال النقر على قائمة الأدوات Tools من شريط القوائم في برنامج ثوني، ثم النقر على خيار إدارة الحزم Manage Packages.

ثالثًا، اكتب "picozero"، ثم انقر على زر البحث Search on PyPi.

رابعًا، انقر على picozero من نتائج البحث ثم انقر على زر التثبيت Install.

استلهم أفكارك

اطلع على المشاريع التالية واستلهم منها بعض الأفكار لصنع آلتك الموسيقية:

• لوحة العزف السحرية

باستخدام مبدّل فوري أنشئ مبدّلًا فوريًا drop switch بلصق قطعة قصدير على مجسم شخصية ما وضعها فوق ورق القصدير ليبدأ العزف السحري.

يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع باسم drop_switch_player.py ضمن الملف المرفق codes.zip.

• آلة الإنذار

شغّل الفيديو ولاحظ أنه عند سحب قطعة الورق المقوى، كما في مشروع مفرقعات الحفلات، ستتلامس قطعتا القصدير (الملصقتان على مشبك الملابس) وتغلق المبدّل، مما سيؤدي إلى تشغيل سلسلة من الأضواء والأصوات المزعجة.

يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع باسم soundalarm.py ضمن الملف المرفق الذكور سابقًا والمتاح بنهاية المقال.

• آلة موسيقية بسيطة

شغّل الفيديو ولاحظ كيف تتحكم المقاومة المتغيرة بسرعة عزف النغمة من الجرس الأول، أما عند الضغط على الزر فتَصدُر عدة نغمات قصيرة من الجرس الثاني.

يمكنك الاطلاع على الشيفرة اللازمة لتنفيذ هذا المشروع باسم dj_desk.py ضمن الملف المرفق.

تصميم الآلة الموسيقية

فكِّر في الغرض من آلتك الموسيقية؟ وما هي الآلية التي سيتبعها المستخدم للتحكم بأصوات الآلة؟

أولًا، يجب عليك اختيار الآلة التي تود صنعها واختيار الغرض منها، ثم اختيار طريقة العزف، واختيار الجمهور المناسب لها، ويمكنك اختيار إحدى الاقتراحات التالية:

• صنع محاكاة لآلة موسيقية ما.
• صنع مشغل موسيقى.
• صنع آلة لتوليد التأثيرات الصوتية. *صنع آلةٍ تولّد أنغامًا مهدئةً، أو مزعجة.

ثانيًا، عليك اختيار نوع الصوت الذي ستصدره الآلة، هل تريد:

• تشغيل نغمات موسيقية محددة، أو أغانٍ كاملة.
• تشغيل أصوات من الطبيعة، مثل صوت الرعد أو زقزقة العصافير.
• تشغيل الصوت حتى انتهائه، أم مقاطعة الصوت عند تشغيل صوت آخر.
• استخدام مقاومة متغيرة للتحكم بطبقة الصوت وسرعته.

عدد العناصر التي يمكن توصيلها مع لوحة راسبيري باي بيكو

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

عليك أخذ النقاط التالية في الحسبان عند التخطيط لآلتك:

• تُشَغّل مكبرات الصوت Speakers كل نغمة على حدى، لذلك ستحتاج لعدة مكبرات صوت لتشغيل عدة نغمات في نفس الوقت.
• توجد رجل تغذية واحدة ذات جهد 3 فولت على لوحة بيكو؛ أي يمكنك استخدام مقاومة متغيرة potentiometer واحدة، كما أنه يوجد حدٌّ لقيمة التيار الذي توفره لوحة بيكو.

إليك بعض الاقتراحات لعناصر الدخل والخرج التي يمكنك استخدامها معًا:

• مقاومة متغيرة واحدة وجرس إلكتروني واحد.
• أربعة أزرار جاهزة وجرس إلكتروني واحد.
• ثمانية أزرار يدوية الصنع وجرس إلكتروني واحد.
• مقاومة متغيرة واحدة وجرسان، وزران.
• عدة أزرار وأجراس لعزف عدة نغمات في نفس الوقت.

ثالثًا، قرر ما هو عدد الأزرار والأجراس التي تريد استخدامها عند تصميم آلتك؟

يمكن لآلتك أن تحتوي على:

• جرس إلكتروني واحد.
• جرسان لخلق تأثير الصوت المجسم، أو عزف النغمة وإيقاعها.
• سمّاعات، وستحتاج حينها إلى ثلاثة دبابيس تثبيت أو ما يُعرف بمشابك التمساح Alligator Clips لتوصيل السمّاعات.
• عدة أجراس إلكترونية.

رابعًا، اختر ما هي العناصر التي تريد استخدامها؟

إليك بعض الاقتراحات:

• زر أو عدة أزرار.
• مقاومة متغيرة للتحكم بنغمة صوت الجرس وسرعة إيقاعه.
• أزرار أو مبدّلات يدوية الصنع.

خامسًا، عليك اختيار الشكل الخارجي للآلة، وتحديد آلية توصيل عناصر الدخل والخرج معها.

تساعدك الإجابة على الأسئلة التالية في اختيار التصميم الخارجي:

• هل تريد اعتماد تصميم مماثل لآلة موسيقية تقليدية، مثل البيانو مثلًا؟
• صنع أزرار أو مبدّلات يدوية؟ وصنع هيكل خارجي للآلة؟
• رسم مشهد ما واستخدام الأزرار لتوليد الأصوات.

لا بأس إذا لم يكن لديك تصورٌ واضحٌ لتصميم الآلة في ذهنك، إذ يمكنك التعديل على تصميمك عند البدء بصنعه.

إضافة الأصوات

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

توصيل الأجراس الإلكترونية والسماعات مع لوحة بيكو

سنعرض فيما يلي كيفية توصيل الأجراس الإلكترونية والسماعات مع لوحة بيكو.

توصيل جرس إلكتروني واحد مع لوحة بيكو

ستحتاج إلى سلكي توصيل نوع مقبس- مقبس socket-socket. صِل الرجل الطويلة،الموجبة للجرس الإلكتروني غير الفعّال مع الرجل GP5 على لوحة بيكو، وصِل الرجل السالبة مع أقرب رجل تأريض GND.

لمعرفة الرجل الموجبة للجرس، ابحث عن الرجل الأطول، أو عن إشارة الموجب + أعلى الجرس.

توصيل جرسين لخلق تأثير الصوت المجسم stereo

ستحتاج لتوصيل جرسين إلكترونيين غير فعّالين مع لوحة بيكو إلى أربعة أسلاك توصيل نوع مقبس- مقبس.

أولًا، صِل الرجل الطويلة الموجبة للجرس الأول مع الرجل GP5 على لوحة بيكو، وصِل الرجل السالبة مع أقرب رجل تأريض GND، ثم صِل الرجل الموجبة للجرس الثاني مع الرجل GP10 على لوحة بيكو، والرجل السالبة مع أقرب رجل تأريض GND.

توصيل السماعات مع لوحة بيكو

ستحتاج لتوصيل السمّاعات مع لوحة بيكو إلى وصلة ذات نهاية بقطر 3 أو 5 مم (وليس وصلة USB)، وثلاثة مشابك تثبيت، وإلى اتباع الخطوات التالية:

1.صِل أحد المشابك مع أحد أرجل الأرض GND القريبة، وصِل المشبكين الآخرين مع الرجل GP5 والرجل GP10، كما هو موضح في الصورة أدناه.

2. صِل نهاية المشبك الأول، الموصول مع الرجل GP5، مع نهاية وصلة السمّاعات.
3. صِل نهاية المشبك الثاني، الموصول مع الرجل GP10،مع منتصف وصلة السمّاعات.
4. صِل نهاية المشبك الموصول مع رجل الأرض GND مع جذر وصلة السمّاعات.

استخدام رجل أرضية مشتركة

تحتوي لوحة بيكو على ثمانية أرجل أرضية GND، لذلك لاستخدام ما يزيد عن ثمانية عناصر إلكترونية عليك إعادة استخدام إحدى الأرجل الأرضية، وستحتاج لما يلي:

• سلك توصيل دبوس- مقبس.
• رقائق قصدير، وشريط لاصق ناقل، أو أي مادة ناقلة للتيار الكهربائي.
• شريط لاصق.

أولًا، أنشئ شريطًا من ورق القصدير، أو من أي مادة ناقلة.

ثانيًا، استخدم الشريط اللاصق لتوصيل سلك أحد الأرجل الأرضية مع شريط القصدير كما يلي:

ثالثًا،صِل القطب الموجب للعنصر الأول مع أحد الأرجل العامة GP على لوحة بيكو، والقطب السالب للعنصر مع شريط القصدير.

رابعًا، لتوصيل المزيد من العناصر، صِل القطب الموجب للعنصر مع إحدى أرجل الأغراض العامة GP، والقطب السالب مع شريط القصدير.

كتابة الشيفرة اللازمة لربط اللوحة مع الجرس

استورد تابع المكبر الصوتي Speaker من مكتبة picozero، ثم أسند أرقام أرجل لوحة بيكو مع الجرس الوحيد للتابع Speaker:

from picozero import Speaker

speaker = Speaker(5)

وتكون الشيفرة اللازمة لتوصيل جرسين على النحو التالي:

from picozero import Speaker

speaker_1 = Speaker(5)
speaker_2 = Speaker(10)

ننصحك بتسمية المتغيرات Variables بأسماء تدل على وظيفتها، مثلًا عند إسناد صوت الطبل للمتغير Speaker_1 فسمّه drum_beat.

كتابة الشيفرة اللازمة لإصدار الصوت

عرّف دالة الصوت بكتابة def قبل اسم الدالة، ثم اختر اسمًا مناسبًا ومعبرًا عن الصوت الذي ستصدره آلتك، فعلى سبيل المثال، إذا أردت أن تصدر آلتك صوتًا مزعجًا، فسمِّ دالة الصوت annoying_sound.

def sound_1(): # استبدل الدالة باسم دالتك

معلومة: موسيقا Chiptune الرُقاقة أو ما يُعرف بموسيقا الثمانية بتات، هي موسيقا صُنعية تُوَّلد بواسطة برمجة الرقائق المسؤولة عن إصدار الصوت في الحواسيب لتصدر أصواتًا ذات ترددات معينة، استعاضةً عن استخدام الآلات الموسيقية التقليدية. تجد هذا النوع من الموسيقا في ألعاب الفيديو ذات طراز الريترو Retro، وفي صالات الألعاب.

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

معلومات مفيدة يجب معرفتها

دعنا نطلع على بعض المعلومات المفيدة عن الأصوات قبل كتابة الشيفرة:

النغمات المتاحة

تُوفر لنا مكتبة "picozero" ثمان وثمانين علامةً موسيقية، تتبع التدوين الغربي للموسيقا وتشمل جميع العلامات الموجودة في لوحة مفاتيح موسيقية كاملة الحجم.

إليك بعض العلامات المُتاحة:

• b0
• c1
• c#1
• d1
• d#1
• e1
• f1
• f#1

طول النغمة

توجد عدة طرق لتحديد طول النغمة، هي:

أولًا، تحديد طول نغمة واحدة باستخدام القيم، إذ يمكنك تحديد مدة النغمة الواحدة بإدخال قيمة في حقل الوسيط الثاني في دالة العزف:

speaker.play(c_note, 0.1) # اعزف النغمة لمدة 0.1 ثانية

ستُعزَف النغمة C في مثالنا لمدة 0.1 ثانية.

ثانيًا، تحديد طول نغمة واحدة باستخدام الثوابت، إذ يمكنك التصريح عن أحد الثوابت في حقل الوسيط الثاني في دالة العزف بدلًا عن القيمة، وتعريف هذا الثابت، وذلك كما يلي:

BEAT = 1 # BEAT تعريف الثابت

speaker.play(c_note, BEAT) # اعزف النغمة لمدة ثانية واحدة

لاحظ أنه يمكننا استخدام الثابت BEAT لتحديد طول أي نغمة.

ثالثًا، تحديد طول مجموعة من النغمات باستخدام القيم، فعند عزف لحن ما، يُفضل تخزين النغمات وطول كل منها في قائمة list، كما في مثالنا التالي، إذ خزّنا كل نغمة مع طولها في قائمة، وجمعنا النغمات الثلاث في قائمة:

my_tune = [ ['d5', 1], ['d#5', 0.5], ['f5', 1.2]] # قائمة بالنغمات وطول كل منها

احرص على كتابة النغمة ضمن علامتي اقتباس ' '.

رابعًا، تحديد طول مجموعة من النغمات باستخدام الثوابت، بحيث نبدأ باستخدام الثابت BEAT، إذ اخترنا في مثالنا القيمة 0.4، ثم نصرّح عن النغمات التي نود عزفها في قائمة ضمن علامتي ' '، ونستخدم الثابت BEAT لتحديد طول النغمات:

BEAT = 0.4 # طول النغمة الواحدة

my_tune = [ ['d5', BEAT], ['d#5', BEAT / 2], ['f5', BEAT * 1.5]] # قائمة بالنغمات وطول كل منها

للتحكم بعدد النغمات في الدقيقة BPM يمكنك تقسيم الثابت BEAT على عدد ما للحصول على نغمات أقصر، مثلًا 2 / BEAT، أو مضاعفته بضربه بعدد ما للحصول على نغمات أطول، مثلا BEAT*1.5.

استخدام الأرقام عوضا عن النغمات

يمكنك الاستعاضة عن النغمات باستخدام قيم الترددات الموافقة لها، والتي تتراوح بين القيمة 150 إلى 10000، إليك المثال التالي لعزف نغمة ذات التردد 523 لثانية واحدة:

speaker.play(523, 1) # اعزف النغمة ذات التردد 523 لثانية واحدة

تحويل المقطوعات الموسيقية إلى نغمات

تُتيح لنا مكتبة picozero عزف المقطوعات الموسيقية الشهيرة واستخدامها في مشاريعنا، إذ تستخدم الأحرف الإنجليزية للدلالة على العلامات الموسيقية، والأرقام للدلالة على موقع العلامة في السلم الموسيقي الكبير.

على سبيل المثال، توجد العلامة C الوسطى في منتصف السلم الموسيقي ويعبر عنها بالرمز C4.

تزداد الأرقام التي تدل على العلامة كلما صعدنا في السلم الكبير، وتنقص عند النزول.

تحتوي المقطوعة الموسيقية علامات حادة يُشار إليها بالرمز # وتدعى "دييز". في مثالنا أدناه، توجد عدة علامات موسيقية حادة، أولها العلامة C الحادة والتي يرمز لها c#4.

وقد تحتوي المقطوعة الموسيقية على علامات بسيطة يُشار إليها بالرمز ♭ وتدعى "بيمول"، لكن سنشير إليها في مشروعنا بالرمز # لعدم احتواء مكتبة "picozero" على شيفرة خاصة للدلالة على العلامات البسيطة، وعلينا النزول نصف درجة في السلم الموسيقي للتحويل من علامة بسيطة إلى حادة.

إليك الأمثلة التالية:

• تتحوّل العلامة البسيطة D إلى C حادة أو c#4.
• تتحوّل العلامة البسيطة E إلى D حادة أو d#4.
• تتحوّل العلامة البسيطة G إلى F حادة أو f#4.
• تتحوّل العلامة البسيطة A إلى G حادة أو g#4.

أمثلة عن بعض الشيفرات الموسيقية

إليك مثالًا عن الشيفرة اللازمة لعزف علامة موسيقية واحدة ولتكن العلامة C الوسطى مثلًا لمدة نصف ثانية:

def c_note():
   speaker.play('c4', 0.5) # اعزف العلامة لمدة نصف ثانية

أما لعزف لحن موسيقي، لا بُد من تخزين النغمات وطول كل منها في قائمة للحصول على لحن ما، ثم تشغيل اللحن باستخدام دالة play، كما هو مبين في الشيفرة التالية:

BEAT = 0.4

liten_mus = [ ['d5', BEAT / 2], ['d#5', BEAT / 2], ['f5', BEAT], ['d6', BEAT], ['a#5', BEAT], ['d5', BEAT],
              ['f5', BEAT], ['d#5', BEAT], ['d#5', BEAT], ['c5', BEAT / 2],['d5', BEAT / 2], ['d#5', BEAT],
              ['c6', BEAT], ['a5', BEAT], ['d5', BEAT], ['g5', BEAT], ['f5', BEAT], ['f5', BEAT], ['d5', BEAT / 2],
              ['d#5', BEAT / 2], ['f5', BEAT], ['g5', BEAT], ['a5', BEAT], ['a#5', BEAT], ['a5', BEAT], ['g5', BEAT],
              ['g5', BEAT], ['', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT / 2], ['d6', BEAT / 2], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT / 2], ['g5', BEAT / 2], ['a5', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT],
              ['f5', BEAT], ['f5', BEAT], ['f5', BEAT / 2], ['d#5', BEAT / 2], ['d5', BEAT], ['f5', BEAT], ['d6', BEAT],
              ['d6', BEAT / 2], ['c6', BEAT / 2], ['b5', BEAT], ['g5', BEAT], ['g5', BEAT], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT], ['f5', BEAT], ['d6', BEAT], ['a5', BEAT], ['a#5', BEAT * 1.5] ]

def play_liten_mus():
    speaker.play(liten_mus)

الشيفرة اللازمة لتوليد تأثيرات صوتية مختلفة باستخدام الترددات

يمكننا توليد تأثيرات صوتية ممتعة، أو مزعجة، وذلك بعزف نغمات قصيرة ذات ترددات مختلفة، إذ أنه كلما تغير التردد تختلف العلامة الموسيقية التي نسمعها وتختلف نغمتها.

إليك الشيفرة التالية التي ترتفع فيها الترددات تدريجيًا لخلق صوت مبهج:

def win(): # ترددات متزايدة
    for i in range(2000, 5000, 100):
        speaker.play(i, 0.05) # اعزف النغمة لمدة قصيرة جدًا

أما المثال التالي، فقد خفضنا فيه الترددات تدريجيًا لتوليد صوت زقزقة العصافير:

def chirp(): # توليد صوت زقزقة العصافير
    for _ in range(2): # decreasing frequency
        for i in range(5000, 2999, -100):
            speaker.play(i, 0.02) # اعزف النغمة لمدة قصيرة جدًا
        sleep(0.2)

غَيّر الترددات المستخدمة في حلقة التكرار for واستخدم الترددات ضمن المجال من 150 إلى 10000.

الشيفرة اللازمة لتوليد ضجيج أبيض من صوت قرع الطبل

from picozero import Speaker
from time import sleep
from random import randint

speaker = Speaker(5)

for i in range(100):
    speaker.play(randint(500, 5000), duration=None)
    sleep(0.001)
    speaker.stop()
    sleep(0.5)

الشيفرة اللازمة لعزف النغمات بصورة متكررة

أنشئ قائمةً بالنغمات التي تريد عزفها وطول كل منها للحصول على لحن ما، ثم استخدم حلقة تكرار for لتشغيل اللحن نغمةً نغمة باستخدام الدالة play:

BEAT = 0.4

liten_mus = [ ['d5', BEAT / 2], ['d#5', BEAT / 2], ['f5', BEAT], ['d6', BEAT], ['a#5', BEAT], ['d5', BEAT],
              ['f5', BEAT], ['d#5', BEAT], ['d#5', BEAT], ['c5', BEAT / 2],['d5', BEAT / 2], ['d#5', BEAT],
              ['c6', BEAT], ['a5', BEAT], ['d5', BEAT], ['g5', BEAT], ['f5', BEAT], ['f5', BEAT], ['d5', BEAT / 2],
              ['d#5', BEAT / 2], ['f5', BEAT], ['g5', BEAT], ['a5', BEAT], ['a#5', BEAT], ['a5', BEAT], ['g5', BEAT],
              ['g5', BEAT], ['', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT / 2], ['d6', BEAT / 2], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT / 2], ['g5', BEAT / 2], ['a5', BEAT / 2], ['a#5', BEAT / 2], ['c6', BEAT],
              ['f5', BEAT], ['f5', BEAT], ['f5', BEAT / 2], ['d#5', BEAT / 2], ['d5', BEAT], ['f5', BEAT], ['d6', BEAT],
              ['d6', BEAT / 2], ['c6', BEAT / 2], ['b5', BEAT], ['g5', BEAT], ['g5', BEAT], ['c6', BEAT / 2],
              ['a#5', BEAT / 2], ['a5', BEAT], ['f5', BEAT], ['d6', BEAT], ['a5', BEAT], ['a#5', BEAT * 1.5] ]

for note in liten_mus:
    speaker.play(note)