در قسمت قبل از مجموعه آموزش برنامهنویسی Embedded C، با فایلهای متنی و باینری، توابع fread و fwrite و نحوه مدیریت بافرها آشنا شدیم. یاد گرفتیم که چگونه اطلاعات را از فایل بخوانیم، در فایل ذخیره کنیم و با استفاده از توابع استاندارد زبان C عملیات ورودی و خروجی را انجام دهیم.
اما یک سؤال مهم وجود دارد: اگر بخواهیم هنگام اجرای برنامه، اطلاعاتی مانند نام فایل، مسیر ذخیرهسازی یا تنظیمات اجرایی را به برنامه بدهیم، چه باید بکنیم؟ آیا لازم است هر بار کد برنامه را تغییر دهیم؟ پاسخ این سؤال استفاده از آرگومانهای خط فرمان (Command Line Arguments) است. این قابلیت به ما اجازه میدهد اطلاعات موردنیاز برنامه را مستقیماً هنگام اجرای آن وارد کنیم.
در قسمت ۳۷، ابتدا با آرگومانهای خط فرمان و نحوه استفاده از آنها در تابع main آشنا میشویم. سپس به سراغ ورودی و خروجی سطح پایین یا Raw I/O میرویم و یک برنامه کاربردی برای کپی فایلها مینویسیم.
هنگامی که یک برنامه را از طریق ترمینال یا خط فرمان اجرا میکنیم، میتوانیم علاوه بر نام برنامه، اطلاعات دیگری نیز به آن ارسال کنیم. این اطلاعات آرگومانهای خط فرمان نام دارند. برای مثال، فرض کنید برنامهای با نام prog نوشتهایم. میتوانیم آن را به شکل زیر اجرا کنیم:
| 1 | ./prog first second third |
در این دستور، ./prog برنامهای است که اجرا میشود و عبارتهای first، second و third آرگومانهایی هستند که به برنامه ارسال میشوند. در واقع، بدون تغییر کد برنامه میتوانیم در هر اجرا اطلاعات متفاوتی را به آن بدهیم.
این ویژگی در برنامههای کاربردی، ابزارهای خط فرمان، برنامههای پردازش فایل و بسیاری از ابزارهای توسعه سیستمهای امبدد استفاده میشود.
تا اینجا معمولاً تابع اصلی برنامه را به شکل زیر نوشتهایم:
| 1 2 3 4 | int main(void) { return 0; } |
اما برای دریافت آرگومانهای خط فرمان میتوانیم تابع main را با دو پارامتر تعریف کنیم:
| 1 2 3 4 | int main(int argc, char *argv[]) { return 0; } |
در این تعریف، دو پارامتر مهم داریم:
عبارت argc مخفف Argument Count است و تعداد آرگومانهایی را مشخص میکند که هنگام اجرای برنامه دریافت شدهاند. در اجرای معمول برنامه از طریق خط فرمان، نام برنامه نیز در این تعداد محاسبه میشود.
عبارت argv مخفف Argument Vector است و آرایهای از رشتهها را در اختیار برنامه قرار میدهد. هر عضو این آرایه به یکی از آرگومانهای خط فرمان اشاره میکند. برای مثال، اگر دستور زیر اجرا شود:
| 1 | ./prog first second third |
مقدار argc برابر با ۴ خواهد بود و عناصر argv به شکل زیر مقداردهی میشوند:
| متغیر | مقدار | توضیح |
|---|---|---|
argc | 4 | تعداد کل آرگومانها شامل نام برنامه |
argv[0] | ./prog | نام یا مسیر اجرای برنامه |
argv[1] | first | اولین آرگومان کاربر |
argv[2] | second | دومین آرگومان کاربر |
argv[3] | third | سومین آرگومان کاربر |
نکته مهم این است که اندیس آرایه argv از صفر شروع میشود. همچنین طبق استاندارد زبان C، عنصر argv[argc] یک اشارهگر تهی یا NULL است.
نمایش ساختار argc و argv در حافظه و ارتباط آرگومانهای خط فرمان با عناصر آرایه
برای درک بهتر عملکرد argc و argv، برنامهای مینویسیم که تمام آرگومانهای دریافتی را همراه با شماره آنها نمایش دهد.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | #include <stdio.h> int main(int argc, char *argv[]) { printf("Number of arguments: %d\n", argc); for (int i = 0; i < argc; i++) { printf("argv[%d] = %s\n", i, argv[i]); } return 0; } |
این برنامه ابتدا تعداد آرگومانها را چاپ میکند. سپس با استفاده از یک حلقه for، عناصر آرایه argv را از اندیس صفر تا argc - 1 نمایش میدهد. برای کامپایل برنامه در محیط لینوکس یا سیستمهایی که کامپایلر GCC دارند، میتوانیم از دستور زیر استفاده کنیم:
| 1 | gcc -std=c11 -Wall -Wextra echo.c -o echo |
اکنون برنامه را با چند آرگومان اجرا میکنیم:
| 1 | ./echo Arduino STM32 ESP32 |
خروجی برنامه به شکل زیر خواهد بود:
| 1 2 3 4 5 | Number of arguments: 4 argv[0] = ./echo argv[1] = Arduino argv[2] = STM32 argv[3] = ESP32 |
همانطور که مشاهده میکنید، برنامه بدون نیاز به تغییر کد، اطلاعات جدید را هنگام اجرا دریافت کرده است.
در بسیاری از برنامهها لازم است کاربر تعداد مشخصی آرگومان وارد کند. برای مثال، برنامهای که قرار است دو عدد را دریافت کند، باید بررسی کند که دقیقاً دو آرگومان از کاربر دریافت شده است. از آنجا که نام برنامه نیز محاسبه میشود، برای دریافت دو مقدار باید argc برابر با ۳ باشد.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { if (argc != 3) { fprintf(stderr, "Usage: %s <value1> <value2>\n", argv[0]); return EXIT_FAILURE; } printf("First value: %s\n", argv[1]); printf("Second value: %s\n", argv[2]); return EXIT_SUCCESS; } |
در این برنامه، اگر تعداد آرگومانها درست نباشد، یک پیام راهنما با استفاده از fprintf در خروجی خطای استاندارد یا stderr نمایش داده میشود. استفاده از EXIT_SUCCESS و EXIT_FAILURE نیز مشخص میکند که برنامه با موفقیت اجرا شده یا با خطا پایان یافته است.
نکته: تمام آرگومانهای موجود در argv به شکل رشته دریافت میشوند. بنابراین، اگر قرار باشد یک آرگومان را به عنوان عدد پردازش کنیم، باید آن را به مقدار عددی تبدیل و معتبر بودن آن را بررسی کنیم. یکی از توابع مناسب برای این کار strtol است.
همچنین اگر یک آرگومان شامل فاصله باشد، معمولاً باید آن را در علامت نقلقول قرار دهیم:
| 1 | ./echo "Embedded C Programming" |
در این حالت، عبارت داخل نقلقول به عنوان یک آرگومان در اختیار برنامه قرار میگیرد.
در قسمت ۳۶ با توابعی مانند fopen، fread، fwrite و fclose کار کردیم. این توابع بخشی از کتابخانه استاندارد ورودی و خروجی زبان C هستند و معمولاً از بافر برای بهبود عملکرد استفاده میکنند. اما در بسیاری از سیستمعاملها، روش دیگری برای کار با فایلها وجود دارد که به آن Raw I/O یا ورودی و خروجی سطح پایین گفته میشود. در این روش به جای استفاده از ساختار FILE و توابع استاندارد stdio، از رابطهایی مانند open، read، write و close استفاده میکنیم.
این رابطها در سیستمهای سازگار با POSIX مانند لینوکس کاربرد دارند و برخلاف توابع stdio، بخشی از استاندارد اصلی زبان C نیستند. نکته مهم این است که Raw I/O به معنای حذف تمام بافرهای سیستمعامل نیست؛ بلکه به این معناست که برنامه از لایه بافرگذاری کتابخانه stdio استفاده نمیکند و مستقیماً با رابط ورودی و خروجی سیستمعامل کار میکند.
| ویژگی | Buffered I/O | Raw I/O |
|---|---|---|
| رابط مورد استفاده | کتابخانه استاندارد stdio | رابط ورودی و خروجی سیستمعامل |
| توابع رایج | fopen، fread، fwrite، fclose | open، read، write، close |
| شناسه فایل | اشارهگر FILE* | File Descriptor |
| بافرگذاری کتابخانه | معمولاً دارد | بافر stdio ندارد |
| قابلیت حمل | بخشی از استاندارد C | وابسته به رابط سیستمعامل |
هیچکدام از این دو روش در تمام شرایط سریعتر از دیگری نیست. عملکرد واقعی به اندازه بافر، نوع فایل، دستگاه ذخیرهسازی و نحوه استفاده از توابع بستگی دارد.
مقایسه مسیر انتقال داده در Buffered I/O و Raw I/O از برنامه تا سیستمعامل و حافظه ذخیرهسازی
در روش Raw I/O، سیستمعامل برای فایل بازشده یک شناسه عددی به نام File Descriptor یا به اختصار fd در اختیار برنامه قرار میدهد. این شناسه برای شناسایی فایل در عملیات خواندن، نوشتن و بستن استفاده میشود.
برای مثال، در سیستمهای POSIX معمولاً سه شناسه زیر از ابتدای اجرای برنامه در دسترس هستند:
| شناسه | نام | کاربرد |
|---|---|---|
| 0 | Standard Input | ورودی استاندارد |
| 1 | Standard Output | خروجی استاندارد |
| 2 | Standard Error | خروجی خطا |
برای باز کردن فایل در سیستمهای POSIX از تابع open استفاده میکنیم.
| 1 | int fd = open("data.bin", O_RDONLY); |
در این دستور، فایل data.bin فقط برای خواندن باز میشود. اگر عملیات موفق باشد، یک شناسه فایل نامنفی برگردانده میشود و در صورت خطا، مقدار -1 بازمیگردد. چند پرچم مهم برای باز کردن فایل عبارتاند از:
| پرچم | کاربرد |
|---|---|
O_RDONLY | باز کردن فایل برای خواندن |
O_WRONLY | باز کردن فایل برای نوشتن |
O_RDWR | باز کردن فایل برای خواندن و نوشتن |
O_CREAT | ایجاد فایل در صورت وجود نداشتن |
O_TRUNC | خالی کردن محتوای فایل موجود هنگام باز شدن برای نوشتن |
پس از باز کردن فایل میتوانیم با استفاده از تابع read اطلاعات آن را بخوانیم.
| 1 | ssize_t bytes_read = read(fd, buffer, size); |
در این دستور، fd شناسه فایل، buffer محل ذخیره دادههای خواندهشده و size حداکثر تعداد بایتهای درخواستی است. مقدار بازگشتی تابع read سه حالت مهم دارد:
باید توجه داشته باشیم که تابع read ممکن است تعداد بایت کمتری از مقدار درخواستی برگرداند. بنابراین همیشه باید مقدار بازگشتی آن بررسی شود.
تابع write برای ارسال دادهها به فایل یا سایر مقصدهای ورودی و خروجی استفاده میشود.
| 1 | ssize_t bytes_written = write(fd, buffer, size); |
این تابع تعداد بایتهایی را که واقعاً نوشته شدهاند برمیگرداند. ممکن است مقدار بازگشتی از تعداد بایتهای درخواستی کمتر باشد؛ به همین دلیل، برنامه باید نوشتن بخش باقیمانده را نیز مدیریت کند.
پس از پایان عملیات، شناسه فایل باید با استفاده از تابع close بسته شود:
| 1 | close(fd); |
بستن فایل باعث آزاد شدن منابع مرتبط با آن در سیستمعامل میشود. همچنین بهتر است نتیجه تابع close بررسی شود؛ زیرا ممکن است برخی خطاهای ورودی و خروجی هنگام بستن فایل گزارش شوند.
اکنون میخواهیم مفاهیم آرگومانهای خط فرمان و Raw I/O را در یک برنامه واقعی ترکیب کنیم. هدف این است که برنامه دو آرگومان دریافت کند: نام فایل مبدأ و نام فایل مقصد. سپس محتوای فایل مبدأ را خوانده و در فایل مقصد ذخیره کند. برنامه به این شکل اجرا خواهد شد:
| 1 | ./copy input.bin output.bin |
در این مثال، input.bin فایل مبدأ و output.bin فایل مقصد است.
برای انتقال اطلاعات، از یک بافر ۱۰۲۴ بایتی استفاده میکنیم. این اندازه مطابق مثال آموزشی فصل ۱۵ انتخاب شده است و لزوماً بهترین اندازه بافر برای تمام سیستمها نیست.
کد زیر نسخه آموزشی تکمیلشدهای از ایده کپی فایل در فصل ۱۵ است. در این نسخه، بررسی خطا، نوشتن ناقص و خالی کردن محتوای قبلی فایل مقصد نیز در نظر گرفته شده است.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <fcntl.h> #include <unistd.h> #include <sys/stat.h> #define BUFFER_SIZE 1024 int main(int argc, char *argv[]) { if (argc != 3) { fprintf(stderr, "Usage: %s <source> <destination>\n", argv[0]); return EXIT_FAILURE; } int in_fd = open(argv[1], O_RDONLY); if (in_fd == -1) { perror("Cannot open source"); return EXIT_FAILURE; } int out_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666); if (out_fd == -1) { perror("Cannot open destination"); close(in_fd); return EXIT_FAILURE; } char buffer[BUFFER_SIZE]; int status = EXIT_SUCCESS; while (1) { ssize_t nread = read(in_fd, buffer, sizeof(buffer)); if (nread == 0) break; if (nread < 0) { if (errno == EINTR) continue; perror("Read error"); status = EXIT_FAILURE; break; } ssize_t offset = 0; while (offset < nread) { ssize_t nwritten = write( out_fd, buffer + offset, (size_t)(nread - offset) ); if (nwritten < 0) { if (errno == EINTR) continue; perror("Write error"); status = EXIT_FAILURE; break; } if (nwritten == 0) { fprintf(stderr, "Write returned zero\n"); status = EXIT_FAILURE; break; } offset += nwritten; } if (status != EXIT_SUCCESS) break; } if (close(in_fd) != 0) { perror("Close source error"); status = EXIT_FAILURE; } if (close(out_fd) != 0) { perror("Close destination error"); status = EXIT_FAILURE; } return status; } |
این نمونه برای سیستمهای POSIX مانند لینوکس نوشته شده است. برای اجرای آن در ویندوز ممکن است به رابطهای متفاوت یا نسخه سازگار با محیط کامپایل نیاز باشد.
هشدار: برنامه فایل مقصد را در صورت وجود بازنویسی میکند. برای آزمایش، از فایلهای نمونه استفاده کنید و نام فایل مبدأ و مقصد را یکسان انتخاب نکنید.
open فایل مبدأ در حالت فقط خواندنی باز میشود.read دادهها را در بافر ۱۰۲۴ بایتی قرار میدهد.write به فایل مقصد منتقل میشوند.در این برنامه از نوع ssize_t برای دریافت نتیجه تابع read استفاده شده است. این موضوع اهمیت دارد؛ زیرا تابع read در صورت خطا مقدار منفی برمیگرداند و نوع داده باید توانایی نگهداری آن را داشته باشد. همچنین از O_TRUNC استفاده کردهایم تا اگر فایل مقصد از قبل وجود داشت، محتوای قبلی آن پیش از کپی پاک شود. بدون این پرچم، ممکن است بخش انتهایی محتوای قدیمی فایل مقصد باقی بماند. مقدار 0666 نیز مجوزهای اولیه فایل جدید را مشخص میکند. این مقدار در سیستمهای POSIX با توجه به تنظیمات umask محدود میشود.
فلوچارت کپی فایل: دریافت آرگومانها، باز کردن فایلها، خواندن ۱۰۲۴ بایت، نوشتن دادهها و بستن فایلها
یکی از موضوعات مهم هنگام کار با فایلها، تفاوت میان حالت متنی و باینری است. در برخی محیطها، هنگام نوشتن فایل در حالت متنی، کاراکتر پایان خط ممکن است به شکل مخصوص سیستمعامل تبدیل شود. برای مثال، در سیستمهای لینوکس و نسخههای امروزی macOS، پایان خط معمولاً با کاراکتر \n مشخص میشود. اما در فایلهای متنی ویندوز، توالی \r\n رایج است.
اگر اطلاعات باینری مانند تصویر، فایل صوتی یا دادههای خام را ذخیره میکنیم، نباید بایتهای فایل در اثر تبدیل پایان خط تغییر کنند. در کتابخانه استاندارد C میتوانیم برای باز کردن فایل باینری از حالتهای rb و wb استفاده کنیم:
| 1 2 3 | FILE *input = fopen("input.bin", "rb"); FILE *output = fopen("output.bin", "wb"); |
در رابطهای سطح پایین برخی محیطها نیز پرچمی به نام O_BINARY وجود دارد که برای جلوگیری از تبدیل دادههای باینری استفاده میشود. در لینوکس و رابطهای POSIX رایج، چنین تبدیل متنی در توابع read و write انجام نمیشود و معمولاً نیازی به پرچم O_BINARY نیست.
مقایسه بایتهای پایان خط LF و CRLF و نحوه ذخیره داده در حالت متنی و باینری
در سیستمهای شبهیونیکس، علاوه بر خواندن و نوشتن اطلاعات، گاهی لازم است تنظیمات یا وضعیت یک دستگاه را نیز کنترل کنیم. برای مثال، ممکن است بخواهیم تنظیمات یک دستگاه ارتباطی را تغییر دهیم یا یک درخواست کنترلی خاص به درایور دستگاه ارسال کنیم.
در چنین شرایطی، یکی از رابطهای مورد استفاده تابع ioctl است. شکل مفهومی فراخوانی این تابع به صورت زیر است:
| 1 | ioctl(fd, request, parameter); |
در این دستور:
fd شناسه فایل یا دستگاهی است که میخواهیم کنترل کنیم.request نوع درخواست کنترلی را مشخص میکند.parameter اطلاعات موردنیاز درخواست را در اختیار تابع قرار میدهد.نوع درخواست، پارامترها و مقدار بازگشتی ioctl به دستگاه و رابط سیستمعامل بستگی دارد. بنابراین، برای استفاده واقعی از این تابع باید مستندات درایور یا دستگاه موردنظر را بررسی کنیم. در سیستمهای لینوکسی، این تابع در برخی درایورهای دستگاه، رابطهای ارتباطی و تجهیزات خاص استفاده میشود. البته بسیاری از تنظیمات رایج، مانند پیکربندی ترمینال و ارتباط سریال، رابطهای تخصصی دیگری نیز دارند.
نکته: تابع ioctl جزو استاندارد زبان C نیست و در تمام سیستمعاملها یا میکروکنترلرهای Bare Metal به یک شکل در دسترس نخواهد بود.
ارتباط برنامه کاربردی با درایور دستگاه از طریق ioctl و مسیر ارسال درخواست کنترلی
اگرچه بسیاری از میکروکنترلرهای Bare Metal فاقد سیستمعامل و خط فرمان معمول هستند، مفهوم آرگومانهای خط فرمان در ابزارهای توسعه سیستمهای امبدد اهمیت زیادی دارد. برای مثال، ابزارهای برنامهریزی حافظه فلش، نرمافزارهای تبدیل فایل، ابزارهای پردازش Firmware و برنامههای تست سختافزار ممکن است تنظیمات خود را از طریق آرگومانهای خط فرمان دریافت کنند.
همچنین در سیستمهای دارای Embedded Linux میتوان برنامههای نوشتهشده با زبان C را مستقیماً از ترمینال اجرا کرد و تنظیمات لازم را هنگام اجرا در اختیار آنها قرار داد. برای نمونه، یک ابزار فرضی برای پردازش Firmware میتواند به این شکل اجرا شود:
| 1 | ./firmware_tool input.bin output.bin |
در این مثال، برنامه میتواند فایل ورودی و خروجی را از آرگومانها دریافت کند. این روش باعث میشود یک برنامه واحد برای فایلها و شرایط مختلف قابل استفاده باشد.
argv[2] دسترسی پیدا کند، ممکن است آرگومان موردنظر وجود نداشته باشد و برنامه با رفتار نامعتبر مواجه شود.argv رشته هستند. برای انجام محاسبات عددی باید آنها را به نوع مناسب تبدیل کنیم و خطاهای احتمالی تبدیل را بررسی کنیم.open، read، write و ioctl بخشی از رابطهای سیستمعامل هستند و نباید آنها را با امکانات استاندارد و قابلحمل زبان C یکسان در نظر بگیریم.تمرینهای عملی قسمت ۳۷
برای تسلط بیشتر بر مفاهیم این قسمت، تمرینهای زیر پیشنهاد میشوند:
-d وجود داشت، عبارت Debug mode و در غیر این صورت عبارت Release mode نمایش داده شود.getopt تحقیق کنید و یک برنامه بنویسید که گزینههای خط فرمان را با استفاده از این تابع پردازش کند.جمعبندی
در این قسمت از آموزش برنامهنویسی Embedded C، با آرگومانهای خط فرمان و نحوه دریافت اطلاعات هنگام اجرای برنامه آشنا شدیم. یاد گرفتیم که پارامتر argc تعداد آرگومانها را مشخص میکند و آرایه argv امکان دسترسی به مقادیر آنها را فراهم میسازد. سپس با مفهوم Raw I/O و توابع open، read، write و close آشنا شدیم و یک برنامه عملی برای کپی فایلها نوشتیم.
در ادامه نیز تفاوت حالت متنی و باینری و کاربرد تابع ioctl در کنترل دستگاهها را بررسی کردیم. این مفاهیم بهویژه در توسعه ابزارهای خط فرمان، برنامههای پردازش فایل و سیستمهای مبتنی بر Embedded Linux کاربرد دارند.
منبع آموزش
این مقاله بر اساس مفاهیم فصل پانزدهم کتاب Bare Metal C: Embedded Programming for the Real World نوشته Steve Oualline، منتشرشده توسط انتشارات No Starch Press تهیه و با توضیحات و مثالهای آموزشی تکمیلی تنظیم شده است.
سیسوگ با افتخار فضایی برای اشتراک گذاری دانش شماست. برای ما مقاله بنویسید.