سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

[spman]

سلام
مدتیه که میکروکنترلرهای مبتنی بر پردازنده آرم بین ما ایرانی ها خیلی رایج شده و میشه گفت به زودی جای avr های هشت بیتی رو میگیره. هرچند یکم دیر اتفاق افتاد...
این میکروکنترلرها مجهز به پردازنده های ARM با کارایی نسبتا بالا هستن. البته ما این عملکرد خوب رو بیشتر به فرکانس کلاک می شناسیم. اما آیا ما تونستیم اونطور که باید از این قدرت میکروکنترلرهای آرم استفاده کنیم؟
چند وقت پیش تاپیکی باز شده بود که چرا فرکانس PIO میکروهای AT91SAM7S/X اینقدر پایینه؟ چه فایده ای داره فرکانس کلاک (و سرعت پردازش پردازنده) بالا باشه اما باس پریفرال با سرعت بالا نداشته باشه و ... دوستان هم جواب های خوبی دادن و مبکروهای دیگه ای هم معرفی شد مخصوص این کار...
اما پس این میکروها چی؟ پردازنده با فرکانس کلاک بالا رو واسه بالابردن کلاس میکرو گذاشتن؟
تو یه پروژه نسبتا حرفه ای و صنعتی، مسئله انجام یکی دو تا وظیفه (task) که نیست. وقتی قرار باشه میکرو تعداد زیادی سنسور و actuator (محرک) رو کنترل کنه، مسئله کارایی خودش رو نشون میده. اینجا به قدرت پردازش بالا نیاز داریم که بتونیم همزمان همه تسک ها رو فعال نگه داریم. پروژه ای رو درنظر بگیرین که قراره از 70 تا سنسور اطلاعات بگیریم پردازش کنیم و به 30 تا actuator فرمان بدیم. (یه پروژه صنعتی نسبتا ساده!!) میکروهای ARM بخاطر فرکانس بالا می تونن گزینه خوبی باشن. اما نوشتن همچین برنامه ای کار ساده ایه؟ توجه کنید که قرار نیست یه حلقه بنویسیم و شروع کنیم یکی یکی سنسورها رو بخونیم و اون لابه لا توابعی رو صدا کنیم و همه چی به خوبی و خوشی...
هر کدوم شرایط خاص خودشون رو دارن. مسئله زمان بندی تسک ها مطرح میشه. بعضا باید همزمان اجرا بشن و نتایح در یک زمان آماده باشه. ممکنه تسک ها رو هم تاثیر داشته باشن. مسئله وابستگی داده ها هست. اشتراک منابع. مسئله اولویت بندی. خیلی از تسک ها ممکنه مدتی کاری واسه انجام دادن نداشته باشن و یا منتظر یک رویداد باشن. با توجه به منابع محدودی که واسه وقفه داریم عملا نمیشه تو یه حلقه معمولی همچین برنامه نوشت و همه تسک ها رو کنترل کرد. اگرم اینطوری سیستم رو پیدا کنیم، مطمئنا به نصف اون کارایی که میشد برسیم نرسیدیم و این میکرو با قدرت پردازش بالا نتونسته کمک خاصی بهمون بکنه.
اینجاست که پای سیستم عامل (به مخصوص از نوع بی درنگ یا realtime) تو طراحی مون باز میشه. با وجود یک سیستم عامل می تونیم همه این تسک ها رو جدا از هم بدون هیچ نگرانی بنویسیم. سیستم عامل با توجه به طراحی ما، مدیریت اجرای تسک ها رو به عهده می گیره. اجرای همزمان تعداد زیاد تسک بدون ایجاد اختلال در عملکرد سیستم، احتیاج به فرکانس کلاک و کارایی بالا داره و اینجاست که میکروکنترلرهای ARM خودشون رو نشون میدن. ساده بگم مثل اینه که 20 تا mega16 رو بذارین کنار هم (با کمی کم لطفی!).
سیستم عامل مزایای دیگه ای هم داره. امکان تقسیم ساده وظایف در پروژه و انجام پروژه بصورت گروهی. ساده شدن عملیات خطایابی با تست تسک ها. امکان گسترش سیستم در مراحل بعد و خیلی دیگه بیشتر از این مجالش نیست!!
به امید خدا تو این تاپیک می خوام نحوه استفاده از سیستم عامل RTX رو بنویسم. تا از این به بعد همه تو پروژه هامون از این سیستم عامل استفاده کنیم و کارامون حرفه ای تر بشه. سیستم عامل های دیگه هم هست. هرکی تونست سیستم عامل های دیگه ای راه بندازه بیاد معرفی کنه. RTX نسبتا خیلی ساده و کتابخونه های خوبی داره. پشتیباتی از شبکه CAN (اینو خودم راه انداختم که بعد از بحث سیستم عامل درموردش مفصل میگم). TCPnet. پشتیبانی از حافظه های FLASH (نمی دونم دقیقا منظورش چیه!). خوبی این کتابخونه ها اینه که بدون درگیرشدن با رجیسترها و مهمتر اینکه با پشتیبانی از امکانات realtime میشه برنامه نویسی کرد.
از اونجایی که می ترسیدم نتونم ادامه بدم و نکنه که شرمنده بشم، تا چندتا پست بعد مطالب رو آماده کردم و کم کم بعد از ویرایش میذارم. خواهشا پست اضافه ندین. اگرم سوالی دارین نپرسین! شوخی کردم بپرسین. اما بذارین چندتا پست بذارم بعد... می خوام بعدها که کسی وارد تاپیک شد بفهمه موضوع جدی دنبال شده و بی تفاوت از کنارش نگذره.

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

یه تاپیک تو بخش avr درمورد سیستم عامل بود. تو این پست خلاصه ای از اون با کمی ویرایش و تکمیل میذارم.
مطالب تئوری خیلی مهمیه !! حتی اگه می بینید نمی فهمین باید خوب بخونید. پست های بعد بیشتر وارد جزئیات میشیم.


multitasking یا "عملکرد چند وظیفه ای" یعنی اینکه بتونیم چند کار رو همزمان انجام بدیم. کرنل (kernel) هسته اصلی هر سیستم عامل، این امکان رو برای سیستم عامل فراهم میکنه که چند برنامه جدا از هم (task) رو با هم اجرا کنه. multitasking این امکان رو به ما میده که برنامه ها یا پروژه های پیچیده رو به چند task ساده تبدیل کنیم که مدیریت و تغییر هرکدوم شون خیلی راحتره.
پردازنده های مرسوم که ما می شناسیم،تنها قابلبت اجرای یک دستور العمل رو در هر زمان (سیکل کلاک) دارن. یعنی به ظاهر میشه با خط به خط اجرا کردن دستورات فقط یک تسک در حال اجرا باشه. اما سیستم عامل با جابجایی سریع تسک ها برای پردازنده، به ظاهر نشون میده که همه درحال اجرا هستن.

scheduler یا زمانبند قسمتی از kernel که تصمیم میگیره در هر لحظه از زمان کدوم تسک باید اجرا بشه. scheduler میتونه یه task رو به حالت معلق در بیاره و درعوض تسک دیگه ای رو اجرا کنه. الگوریتم یه سیستم عامل multitask (نه realtime) اینه که به هر تسک میزان زمان پردازش برابر بده و اصطلاحا زمان پردازنده رو عادلانه(fairly) بین تسک ها تقسیم کنه.
این جابجایی تسک ها بدون اختیار هر تسک توسط scheduler انجام میشه. Round robin یکی از الگوریتم های معروف scheduler. این الگوریتم (که شکل قبل داره نمایشش میده) از این قراره که یه قطعه زمانی مشخص تعیین میشه (مثلا 10 میلی ثانیه) و به هر تسک به این اندازه زمان داده میشه تا پردازنده دستوراتش رو اجرا کنه. اگه اجرای تسک تموم نشه، scheduler اون تسک رو به حالت معلق در میاره و میره سراغ تسک بعد و به همین اندازه زمان پردازش در اختیارش میذاره. این رویه تکرار میشه و تسک ها بصورت چرخشی زمان پردازش از پردازنده میگیرن...
غیر از این، هر تسک هم میتونه خودش رو به حالت معلق در بیاره. فرض کنید یه task بخواد تاخیر ایجاد کنه. مثلا هر 100 میلی ثانیه اجرا بشه. تو این زمان تاخیر، خود تسک اعلام میکنه که عملیاتی برای پردازش نداره و زمان پردازش پردازنده در اختیار تسک دیگه ای قرار میگیره. حالت دیگه اینه که task بخواد با یکی از منابع یا امکانات جانبی (peripheral) پردازنده (مثل پورت سریال) کار کنه، که اگه توسط تسک دیگه ای اشغال باشه، باید خودش رو مسدود کنه و منتظر بمونه تا اون منبع آزاد بشه. حالت های دیگه ای هم هست که یه task خودش رو مسدود میکنه. مثلا منتظر یه وقفه خارجی یا دریافت پیام از تسک دیگه ای باشه و ...
تصویر زیر رو ببینید

در زمان 1 تسک 1 در حال اجراست
در زمان 2 کرنل زمان اجرا رو از تسک 1 میگیره و در عوض اجرای تسک 2 رو ادامه میده (زمان3)
تسک 2 در زمان اجرای خودش (زمان4) یکی از امکانات جانبی (peripheral) رو در احتیار خودش میگیره که با اون کار کنه.
در زمان 5 کرنل زمان پردازش تسک2 رو میگیره و تسک 3 رو ادامه میده(زمان6). توجه کنید که تسک هایی که به حالت معلق در اومدن، کارشون تموم نشده.
تسک 3 می خواد با همون peripheral تسک 2 کار کنه. اما چون این peripheral در اختیار تسک 2 هست، تسک 3 خودش رو مسدود میکنه (زمان 7). بنابراین دوباره تسک 1 ادامه داده میشه (زمان8) و این روند تکرار میشه تا جایی که تسک 2 دست از سر اون peripheral برداره (زمان9).
زمان بعدی که تسک 3 اجرا بشه (زمان10) اون peripheral مشغول نیست و تسک 3 میتونه باهاش کار کنه. همونطور که می بینید تسک 3 به اندازه تسک های دیگه زمان اجرا از کرنل گرفته...

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

RTOS : Real Time Operating System
سیستم های realtime برای پاسخ به رویدادهایی طراحی میشن که این رویدادها برای دریافت پاسخ، اصطلاحا یک ضرب العجل (deadline) دارن. یعنی تو زمان مشخصی حتما باید بهشون پاسخ داده بشه. برای این سیستم ها زمان انجام عمل مورد نظر دقیقا قابل محاسبه هست و نباید از بازه ای که محاسبه میشه تجاوز کنه.
بعد از multitasking خصوصیت بعدی یک سیستم عامل، realtime بودن. اساس کار scheduler سیستم عامل realtime مشابه multitasking اما با هدف متفاوت. هدف scheduler بلادرنگ اینه که deadline رو درنظر بگیره و تا قبل از اتمام فرصت مورد نظر برای یک تسک، عملیات تسک رو کامل کنه.
اینکار چطور ممکن میشه؟
خیلی ساده! برنامه نویس باید برای هر تسک یک اولویت (Priority) تعیین کنه. scheduler همیشه زمان پردازش رو به تسک با اولویت بالاتر میده و تا وقتی تسک با اولویت بالاتر آماده برای اجرا باشه، تسک اولویت پایین تر هیچ زمان پردازشی نمیگیره. در صورتی هم که چند تسک با اولویت برابر آماده اجرا باشن، زمان پردازش بینشون تقسیم میشه.
وقتی چندتا تسک با اولویت برابر تعریف میکنیم. زمان پردازش بینشون تقسیم میشه و سرعت اجرای هر کدوم نسبت به زمانی که به تنهایی اجرا بشن کم میشه. فرض کنید تسکی داریم که 500 میلی ثانیه طول میکشه اجرا بشه (به تنهایی) و تو پروژه ای که داریم هم حتما باید 500 میلی ثانیه باشه نه بیشتر. بنابراین به این تسک نسبت به بقیه تسک ها یک اولویت بالاتر میدیم و اینطوری مطمئنیم که در زمان اجرای این تسک، هیچ پردازش دیگه ای نداریم و تو همون 500 میلی ثانیه انجام میشه.

از پست بعد میریم سر اصل مطلب

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

از سال 2005 که ARM ، شرکت keil رو خرید، تمرکز نرم افزارهای keil رو محصولات ARM شد.
تعدادی از محصولات keil :
uVision IDE (میکرو ویژن) محیط توسعه و دیباگر و شبیه ساز برای محصولات مبتنی بر پردازنده های آرم هست.
ARM Compilation Tools شامل کامپایلر و اسمبلر و لینکر. (معمولا با uVision)
RL-ARM کتابخونه های realtime (سیستم عامل RTX، CAN، TCP/IP ، FLASH و ...)
MDK-ARM مجموعه همه موارد بالا میشه
یه نگاهی به این صفحه بندازین http://www.keil.com/arm/selector.asp
خودم هنوز نفهمیدم نصب اینا چطوریه. من اول keil uvision داشتم. بعدش پدیت MDK-ARM رو دانلود کردم که تونستم از سیستم عاملش استفاده کنم. اما نمی دونم چرا سمپل هاش و یه سری از کتاب خونه های دیگه ش نبود! شاید کامل دانلود نکردم. اگه میکروویژن رو داشته باشین می تونین برین تو سایت keil سمت راستش آخرین updateهای MDK رو گذاشته. ازتون یه شماره LIC می خواد که میتونید تو uVision منوی help و about پیدا کنین. اگه uVision نداشته باشین اینطوری نمی تونین دانلود کنین.
سایت ایران میکرو نسخه کامل MDK رو گذاشته. http://www.iranmicro.ir/keilmdk-263.html

RTX در دو ورژن پیاده سازی شده :
ورژن ARM7/ARM9
ورژن Cortex M
Cortex M ها امکاناتی برای RTOS درنظر گرفتن. بخاطر همین سیستم عامل با عملکرد بهتری دارن. اما از نظر نحوه کارکرد برای ما تقریبا فرقی نمیکنه.
برای راه اندازی RTX در یک پروژه مراحل زیر رو دنبال کنید.
پروژه جدید ایجاد کنید. از منوی Project – Options (باید قبلش target پروژه رو انتخاب کنید) یا رو پنجره Project رو target راست کلیک و options رو انتخاب کنید. تو پنجره باز شده در تب target قسمت operating system ، گزینه RTX Kernel رو انخاب کنید.
فایل پیکربندی (config) سیستم عامل رو با توجه به میکروکنترلر از پوشه Keil/ARM/Startup ، تو پوشه پروژه کپی و به پروژه keil اضافه کنید. مثلا برای سری AT91ASAM7X فایل RTX_Conf_SAM7X.c در پوشه Keil/ARM/Startup/Atmel . بعدا در مورد تنظیمات این فایل توضیح میدم.
تنظیمات مربوط به وقفه های نرم افزاری تو فایل اسمبلی startup باید تغییر کنه. (همون فایل اسمبلی که خود keil به پروژه اضافه میکنه. SAM7.S برای 7 اتمل...). خط SWI_Handler B SWI_Handler رو تو این فایل حذف کنید و بجاش این دستور رو اضافه کنید:
IMPORT SWI_Handler
اول این دستور باید به tab یا فاصله بزنید. خلاصه قسمتی از کد که اینطوریه :

Undef_Handler B Undef_Handler
SWI_Handler B SWI_Handler
PAbt_Handler B PAbt_Handler
DAbt_Handler B DAbt_Handler
IRQ_Handler B IRQ_Handler
FIQ_Handler B FIQ_Handler

باید به این تغییر داده بشه :

Undef_Handler B Undef_Handler
;SWI_Handler B SWI_Handler
IMPORT SWI_Handler
PAbt_Handler B PAbt_Handler
DAbt_Handler B DAbt_Handler
IRQ_Handler B IRQ_Handler
FIQ_Handler B FIQ_Handler

(خط دوم با سمیکالون به کامنت تبدیل شده...) در مورد وقفه های نرم افزاری که در مد supervisor پردازنده اجرا میشن، بعدا که اطلاعاتم بیشتر شد توضیح میدم.
خب الان پروژه باید بدون خطا کامپایل بشه. ضمنا برای استفاده از سیستم عامل باید فایل rtl.h رو هم تو فایل main پروژه include کنید.
این یه نمونه برنامه : (برای AT91SAM7X)

#include <AT91SAM7X256.h>
#include <rtl.h>

__task void task1(void);
__task void task2(void);

int main()
{
*AT91C_PIOB_PER = (1 << 0) | (1 << 1);
*AT91C_PIOB_OER = (1 << 0) | (1 << 1);

os_sys_init(task1);

while(1){}
return 0;
}

__task void task1(void)
{
int i = 0;
os_tsk_create(task2, 1);
while(1){
os_dly_wait(50);
if (i==0){
*AT91C_PIOB_SODR = (1 << 0);
i=1;
}
else{
*AT91C_PIOB_CODR = (1 << 0);
i=0;
}
}
}

__task void task2(void)
{
int i=0;
while(1){
os_dly_wait(25);
if (i==0){
*AT91C_PIOB_SODR = (1 << 1);
i=1;
}
else{
*AT91C_PIOB_CODR = (1 << 1);
i=0;
}
}
}

تو این برنامه دو تا تسک تعریف شده. تو هر تسک یکی از پایه های میکرو بطور جدا (با تاخیر متفاوت) روشن و خاموش میشه. خوب برنامه رو بخونین تا بعد...

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام!
شرمنده تو این پست هم سراغ برنامه نویسی نمیریم!!!

فایل config که به پروژه اضافه کردین رو تو محیط uVision باز کنید. پایین ادیتور روی Configuration Wizard کلیک کنید. اینطوری می تونین بدون درگیر شدن با کدها، تنظیمات رو اتجام بدین.

در بخش Task configuration ، جلوی Number of concurrent running tasks باید تعداد تسک ها مشخص بشه.
در بخش Tick Timer Configuration تنظیمات زمانی انجام میشه. کرنل نیاز به یک سخت افزار تایمر داره که دائم طی بازه زمانی مشخصی توسط اون تایمر صدا زده بشه تا مدیریت تسک ها و اعمال سیستم عامل رو انجام بده. تایمر با وقفه دادن مکرر در فاصله زمانی مشخصی که تعیین می کنیم، اصطلاحا Tick رو ایجاد میکنه و با هر Tick تابع مدیریت سیستم صدا زده میشه. زمان مشخص شده برای Tick خیلی مهمه. تمام توابع سیستم عاملی که به نوعی با زمان در ارتباط هستن، با ضریبی از زمان Tick کار میکنن.
در قسمت Hardware timer می تونین یکی از تایمرها رو انتخاب کنید. (مثلا برای AT91SAM7X بهترین گزینه همون PIT که برای همینکار طراحی شده). جلوی Timer clock value باید فرکانس کلاکی که به تایمر وارد میشه رو تعیین کنید. برای AT91SAM7 اگه کریستال 18.432 داشته باشین و با تنظیمات پیشفرض کیل، master clock با فرکانس 47.9232 دارین و با توجه به تقسیم به 16 تایمر PIT، فرکانس این تایمر، 2.9952 مگاهرتز هست. Timer tick value مدت زمان Tickرو تعیین میکنه. مثلا 10000 میکرو ثانیه (10 میلی ثانیه).
در بخش System configuration اگه گزینه Round Robin task switching انتخاب شده باشه، طبق الگوریتم Round Robin، تسک ها بصورت چرخشی سوییچ میشن. جلوی Round Robin timout باید مشخص کنید که به هر تسک به اندازه چند Tick فرصت پردازش داده بشه. مثلا اگه 5 باشه، و زمان هر Tick هم 10 میلی ثانیه باشه، به هر تسک در هر بار 50 میلی ثانیه فرصت پردازش داده خواهد شد. این همون قطعه زمانی که تو پست مربوط به multitask و scheduler گفتم. همونطور که می بینید scheduler یکی از همون قسمت هایی که با Tick کار میکنه.
هرچقدر زمان Tick کمتر باشه، سیستم عامل با دقت و سرعت بیشتری کار میکنه. اما به همون اندازه که زمان Tick رو کم می کنید، توابع سیستم عاملی بیشتر صدا زده میشن، میزان بیشتری از زمان پردازش رو سیستم عامل میگیره. تو هلپ کیل پیشنهاد کرده زمان Tick بین 1 تا 100 میلی ثانیه باشه. بستگی به سخت افزار و میکرویی که استفاده میکنین داره...
اگه Round Robin رو غیر فعال کنین، جابجایی تسک ها بصورت خودکار (در اون بازه زمانی مشخص) انجام نمیشه و فقط دستورات مدیریتی که تو تسک ها می نویسین روند اجرا رو مشخص میکنه.

اگه سوالی هست بپرسینا...

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام
برای تعریف تسک، از تابعی با مقدار برگشتی از نوع void و مشخصه __task استفاده می کنیم. هر تسک باید به شکل تابعی با حلقه بی پابان باشه.

__task void task1(void);
__task void task1(void)
{
//initialization
while(1){
//task process
}
}

تابع os_sys_init سیستم عامل رو پس از انجام مقداردهی های اولیه، فعال میکنه. این تابع یک آرگومان ورودی برای مشخص کردن اولین تسک برای اجرا داره. یعنی با اجرای این تابع، سیستم عامل فقط یک تسک رو میشناسه. این تسک بطور خودکار اولویت 1 (کمترین اولویت) رو میگیره. دستور بعد از os_sys_init اجرا نمیشه. درواقع بعد از این تابع، فقط تسک ها هستن که اجرا میشن و برنامه به خط بعد از os_sys_init برنمی گرده. پس برای معرفی بقیه تسک ها به سیستم عامل، باید تو تسک اول اقدام کنیم. معرفی تسک ها توسط تابع os_tsk_create انجام میشه. آرگومان اول تابع، نام تسک و آرگومان دوم اولویت که میتونه بین 1 تا 254 باشه. اعداد بزرگتر اولویت بیشتری دارن. اولویت 0 و 255 رزرو شده هستن و نباید استفاده کنیم. خروجی این تایع یک شماره مشخصه از نوع OS_TID برای تسک ایجاد شده که می تونیم ذخیره کنیم. برای بعضی از توابع سیستم عامل باید از شماره تسک برای مشخص کردن تسک استفاده کنیم. بد نیست یه نگاهی به پروتوتایپ این دو تابع بندازیم :

void os_sys_init (
void (*task)(void) ); /* Task to start */

OS_TID os_tsk_create (
void (*task)(void), /* Task to create */
U8 priority ); /* Task priority (1-254) */

این یه نمونه برنامه کامل :

#include <AT91SAM7X256.h>
#include <rtl.h>

__task void task1(void);
__task void task2(void);

int main()
{
//initialization ports for led
*AT91C_PIOB_PER = (1 << 0) | (1 << 1);
*AT91C_PIOB_OER = (1 << 0) | (1 << 1);
*AT91C_PIOB_OWER = (1 << 0) | (1 << 1);

os_sys_init(task1);

while(1){}
return 0;
}

__task void task1(void)
{
int i = 0;
os_tsk_create(task2, 1);
while(1){
for (i = 0; i < 0x7ffff; i++);//process

*AT91C_PIOB_ODSR ^= (1 << 0); //led1
}
}

__task void task2(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x8ffff; i++);//process

*AT91C_PIOB_ODSR ^= (1 << 1); //led2
}
}

تو تابع main بعد از os_sys_init(task1) تابع تسک 1 شروع به اجرا میشه. تو این تابع، تسک 2 هم با اولویت 1 معرفی شده. خب از اینجا به بعد سیستم عامل دو تا تسک با اولویت برابر میشناسه و هر دو رو همزمان اجرا می کنه. هر تسک یه حلقه for داره که مثلا داره یه عمل پردازشی انجام میده... برای اینکه ببینین این دو تا تسک همزمان دارن اجرا میشن، هر کدوم یکی از پین های میکرو not میکنن. به پایه 0 و 1 پورت B یک LED وصل کنید و ببینید (یا شبیه سازی...)

الان باید بدونین چی میشه که دو تا تسک رو همزمان درحال اجرا می بینیم. بخاطر الگوریتم round robin ، هرباز به اندازه قطعه زمانی مشخص شده (50 میلی ثانیه) به هر تسک فرصت پردازش داده میشه. با تسک1 شروع میشه. قسمتی از حلقه for اجرا میشه. بعد از 50 میلی ثانیه، تسک1 رو ول میکنه و تسک2 رو شروع میکنه. بعد از 50 میلی ثانیه (هنوز حلقه for دومی تموم نشده) اینم ول میکنه برمیگرده ادامه حلقه for تسک اول رو ادامه میده. این روند ادامه داره و دو تا تسک همزمان اجرا میشن. هربار هم که به پایان for رسیده شد، led چشمک میزنه.

دستور os_tsk_create(task2, 1) رو به os_tsk_create(task2, 2) تغییر بدین. با این کار اولویت تسک دوم برابر 2 یعنی بیشتر از تسک 1 میشه.اگه برنامه رو اجرا کنین می بینین که دیگه led تسک اول چشمک نمیزنه. دلیلش واضحه. تسک دوم اولویت بیشتری داره و تا وقتی آماده اجرا باشه، سیستم عامل پردازنده رو در اختیار تسک1 قرار نمیده. اگه دقت کنین تسک دوم با سرعت بیشتری نسبت به دفعه قبل اجرا میشه (ledدوم سریعتر چشمک میزنه). خب معلومه بخاطر اینکه تمام زمان پردازش cpu در اختیار تسک دوم قرار گرفته و تسک دیگه ای همزمان باهاش اجرا نمیشه.

ساعت دقیقا 3 نصف شبه! برم بخوابم... oo:

[mohpooria]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

این جور که معلومه RTX فقط برای Keil است، یا میشه در IAR هم ازش استفاده کرد؟

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

این جور که معلومه RTX فقط برای Keil است، یا میشه در IAR هم ازش استفاده کرد؟

کتابخونه RL-RTX مخصوص کامپایلر کیل. تا جایی که من تو کتابخونه هاش وارد شدم همش با کد سی در دسترس هست. شاید بشه با تغییر ویژگی هایی مخصوص کامپایلر (مثل نحوه نوشتن اسمبلی، توابع وقفه و...)، تحت کامپایلر دیگه هم کامپایل کرد. اما خب کار خیلی سختیه...

من دارم در کنار RTX، مفاهیم مهم سیستم عامل رو میگم. اینا رو یاد بگیرین، میتونین سراغ هر سیستم عامل دیگه ای برین... خیلی از سیستم عامل ها هستن که برای کامپایلرهای مختلف پورت شدن.
من با سیستم عامل FreeRTOS شروع کردم که اگه یه سرچی بکنین خیلی معروفه. اما این RTX کیل خیلی قویتر و کاملتره

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام
برنامه پست قبل رو با کمی تغییر دوباره ببینین :

#include <AT91SAM7X256.h>
#include <rtl.h>

OS_TID tsk_ID1, tsk_ID2;
__task void task_init(void);
__task void task1(void);
__task void task2(void);
void blink1(void);
void blink2(void);

int main()
{
os_sys_init(task_init);

while(1){}
return 0;
}

__task void task_init(void)
{
//initialization ports for led
*AT91C_PIOB_PER = (1 << 0) | (1 << 1);
*AT91C_PIOB_OER = (1 << 0) | (1 << 1);
*AT91C_PIOB_OWER = (1 << 0) | (1 << 1);

tsk_ID1 = os_tsk_create(task1, 1); //priority:1
tsk_ID2 = os_tsk_create(task2, 1); //priority:1

os_tsk_delete_self(); //necessary
}

__task void task1(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x7ffff; i++);//process

blink1();
}
}

__task void task2(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x8ffff; i++);//process

blink2();
}
}

void blink1(void)
{
*AT91C_PIOB_ODSR ^= (1 << 0);
}

void blink2(void)
{
*AT91C_PIOB_ODSR ^= (1 << 1);
}

معمولا تسک اول برای مقداردهی اولیه سیستم و معرفی تسک ها برنامه نویسی میشه. همونطور که می بینید تسکی به نام task_init برای این کار تعریف کردم. اگه دقت کنید این تسک به شکل حلقه بی نهایت نیست و کارش تموم میشه و به پایان تابع میرسه. برای همچین تسک هایی و هر تسکی که عملیاتش تحت شرایطی تموم میشه حتما باید در پایان از تابع os_tsk_delete_self استفاده کنید تا سیستم عامل این تسک رو حذف کنه. اگه این کارو نکنید سیستم هنگ میکنه.
تابع دیگه ای هست به نام os_tsk_delete . این تابع می تونه با گرفتن شماره مشخصه هرتسک (از نوع OS_TID) اونو از سیستم حذف کنه (همین یک پارامتر رو داره). یعنی میشه از تو یه تسک، تسک دیگه ای رو حذف کرد. همونطور که تو پست قبل گفتم ID هر تسک، خروجی تابع create اونه. تو کدی که می بینید tsk_ID1 و tsk_ID2 شماره مشخصه task1 و task2 هستن.
تغییر دیگه ای که تو این برنامه می بینید اینه که تو هر تسک تابعی رو برای چشمک زدن فراخوانی کردم. می خوام دو تا نکته بگم: 1- اینطور نیست که تمام عملیات رو تو تسک کامل کدنویسی کنین. میتونین توابع مختلفی رو صدا کنید. 2- نباید واسه هرکاری تسک تعریف کنید. تسک ها برای متمایز کردن برنامه ها و وظیفه های جدا از هم هستن. برای جدا کردن چند روند اجرا. برای... نمی دونم کم کم براتون جا می افته!
هنوز حرف اصلی رو نزدم! هدفم از این پست یه چیز دیگه بود! باشه واسه پست بعد...

[sina_80]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام
1-اینها برای SAM7S64 هم صدق میکنه دیگه؟
2-در این بحثها ما فقط از سیستم عامل نوشته شده RTX استفاده میکنیم، درسته؟ خودمون هم میتونیم یه سیستم عامل بنویسیم؟
ممنون

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام
1-اینها برای SAM7S64 هم صدق میکنه دیگه؟
2-در این بحثها ما فقط از سیستم عامل نوشته شده RTX استفاده میکنیم، درسته؟ خودمون هم میتونیم یه سیستم عامل بنویسیم؟
ممنون

1- توضیحاتی که من میدم مربوط به لایه نرم افزاری سطوح بالاست. سیستم عامل در چند لایه نوشته شده. لایه های سطح پایین مربوط به ارتباط مستقیم با سخت افزار هستن که درخواست های لایه های سطح بالا رو انجام میدن (مثل سوییچ تسک ها). کافبه شما فایل config مربوط به دیوایس رو مشخص کنید. لایه های سخت افزاری خود به خود با توجه به میکرو انتخاب میشن. حالا ممکنه بعضی هاشون پیاده سازی بعضی از توابع رو نداشته باشن و بعضی ها هم امکانات بیشتری داشته باشن که اگه می خواین خیلی دقیق بشین باید وارد کتابخونه ها بشین و پیاده سازی توابع رو ببینین. حالا یه سری مباحث اصلی کامل بشه، اونام بررسی میکنیم
اما دیگه بین sam7s و sam7x فرقی نیست....
برای sam7s از RTX_Conf_SAM7S.c استفاده کنید.

2- نوشتن یه سیسنم عامل کار ساده ای نیست. خیلی زمان بر و احتیاج به تیم برنامه نویسی داره. اما نشدنی هم نیست. اگه کدهای کتاب خونه هاش رو بخونی خیلی راحت متوجه میشی.

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام! یکی از دوستان پیغام داد که از صبح منتظر پست بذارم! منم الان 12 شب پیغامش رو دیدم دلم نیومد بیشتر از این منتظر بمونه. انصافا خیلی تند تند پست میذارم. مراعات کنید دیگه ! نزدیک میان ترمام. هرکی میخونه دعا کنه به درسام برسم، منم زیاد منتظرتون نمیذارم.

خب برنامه پست قبل رو ادامه میدیم. برین تو فایل config و تیک گزینه round robin task switching رو حذف کنید. پروژه رو کامپایل کنید و نتیجه رو ببینین.
فقط تسک اول اجرا میشه! (led دوم چشمک نمیزنه). scheduler سیستم عامل دیگه به شکل round robin عمل نمیکنه. می دونیم که با round robin بعد از هر قطعه زمانی مشخص شده سوییچ تسک انجام میشه. و چون این قطعه زمانی خیلی کوتاه هست، سیستم به ظاهر همه تسک ها رو موازی و همزمان اجرا میکنه.
بدون round robin باید چیکار کرد؟
Cooperative Multitasking
میشه "مشارکتی" ترجمه کرد.
این همون چیزیه که سیستم عامل های اولیه به این شکل عمل میکردن. روند سوییچ تسک ها توسط خود تسک ها مشخص میشه. یعنی خود تسک باید اعلام کنه که فرصت رو در اختیار تسک دیگه قرار بده. دیگه تو برنامه ای که نوشتیم وسط اون حلقه for که مثلا عملیات پردازش رو شبیه سازی میکرد، سوییچ تسک انجام نمیشه. باید بین عملیات تسک به سیستم عامل اعلام کنید زمان پردازش رو در اختیار تسک دیگه ای قرار بده. این کار توسط دستور os_tsk_pass انجام میشه. من هر کدوم از اون حلقه های for رو به چند قسمت تقسیم کردم و وسط اونا به سیستم عامل اعلام کردم که بره سراغ تسک بعد.

__task void task1(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x4ffff; i++); //first portion of process
os_tsk_pass();
for (i = 0; i < 0x4ffff; i++); //second portion of process
os_tsk_pass();
for (i = 0; i < 0x4ffff; i++); //third portion of process
os_tsk_pass();
for (i = 0; i < 0x4ffff; i++); //fourth portion of process

blink1();
}
}

__task void task2(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x5ffff; i++); //first portion of process
os_tsk_pass();
for (i = 0; i < 0x5ffff; i++); //second portion of process
os_tsk_pass();
for (i = 0; i < 0x5ffff; i++); //third portion of process
os_tsk_pass();
for (i = 0; i < 0x5ffff; i++); //fourth portion of process

blink2();
}
}

ما همیشه از round robin استفاده می کنیم. اما در این حالت هم میشه این تابع رو صدا کرد و سوییچ تسک انجام داد (قبل از اینکه قطعه زمانی تسک تموم بشه). اگه این تابع رو صدا بزنین و تسک بعدی اولویت کمتری داشته باشه (یعنی تسک هم اولویت با تسک جاری آماده اجرا نباشه)، سوییچ تسک انجام نمیشه. این تابع همیشه بین تسک های هم اولویت سوییچ میکنه. خب اگه تسک بعد اولویت بیشتری داشته باشه چی؟؟ (یعنی تسکی با اولویت بیشتری منتظر چیزی نباشه و آماده اجرا باشه)؟؟
؟؟
؟؟
به تسک با اولویت بیشتر سوییچ میکنه؟؟
؟؟(تست هوش!)
1- به تسک اولویت بالاتر سوییچ میکنه! 2- سوییچ نمیکنه!! 3-سیستم هنگ میکنه!؟!! 4- ...
؟؟
؟!؟

نه دیگه!! این سیستم عامل یه سیستم عامل بی درنگ (realtime). یعنی هیچ وقت امکان نداره تسک با اولویت بیشتری آماده اجرا باشه و تسک با اولویت کمتری درحال اجرا باشه.

Preemptive multitasking
روش cooperative دیگه جواب گوی سیستم های پیچیده و مخصوصا realtime نبود. این شد که سیستم عامل ها preemptive شدن. یعنی در حالت عادی فقط منتظر دستوری مثل os_tsk_pass نمیشن. و همینطور در حالت round robin منتظر اینتراپت تایمر scheduler نمیشن (که بعد از اون قطعه زمانی سوییچ تسک انجام بشه). در روش Preemptive سیستم عامل به رویدادها پاسخ میده. یعنی هروقت رویدادی اتفاق افتاد که تسک با اولویت بالاتری آماده اجرا شد، بی معطلی سوییچ انجام میشه و اون تسک اجرا میشه. البته این فقط برای تسک های اولویت بالاتر نیست. تسک هایی که با اولویت برابر هم که تو صف اجرای تسک ها هستن اگه بعد از رویدادی آماده اجرا بشن ممکنه درست بعد از تسک جاری زمان پردازش بگیرن. توجه کنید که preemptive کامل شده cooperative. یعنی در این حالت هم os_tsk_pass و round robin عمل میکنن. این سیستم عامل از Preemptive تبعیت میکنه.

حالا اینکه این رویدادها چی هستن و چطوری تعریف میشن باشه واسه پست بعد. ساعت 1 شد!
مطالعه بیشتر :
http://en.wikipedia.org/wiki/Computer_multitasking

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

سلام
تو این پست در مورد توابع تاخیر سیستم عامل میگم. موقع استفاده از سیستم عامل باید از این توابع برای ایجاد تاخیر ایجاد کنین. این بحث در ادامه بحث روند های اجرای تسک ها و preemptive multitasking. البته نمیشه گفت توابع تاخیر دقیقا به سیستم عامل های preemptive مربوط میشه. توابع اصلی رویدادها رو پست بعد میگم...
برای اینکه دقیقا زمان بندی رو ببینین باید برنامه رو پروگرم کنین و در عمل ببینین. در این مورد شبیه ساز اصلا دقیق عمل نمیکنه...


تابع os_dly_wait سیستم عامل، یک ورودی داره که تعداد tick برای ایجاد یه تاخیر رو مشخص می کنه. با مثال توضیح بدم راحتره. برنامه زیر رو ببینین

#include <AT91SAM7X256.h>
#include <rtl.h>

OS_TID tsk_ID1, tsk_ID2, tsk_ID3;
__task void task_init(void);
__task void task1(void);
__task void task2(void);
__task void task3(void);
int main()
{
os_sys_init(task_init);

while(1){}
return 0;
}

__task void task_init(void)
{
//initialization ports for led
*AT91C_PIOB_PER = (1 << 0) | (1 << 1) | (1 << 2);
*AT91C_PIOB_OER = (1 << 0) | (1 << 1) | (1 << 2);
*AT91C_PIOB_OWER = (1 << 0) | (1 << 1) | (1 << 2);

tsk_ID1 = os_tsk_create(task1, 1); //priority:1
tsk_ID2 = os_tsk_create(task2, 1); //priority:1
tsk_ID3 = os_tsk_create(task3, 2); //priority:2

os_tsk_delete_self(); //necessary
}

__task void task1(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x5ffff; i++); //first portion of process
for (i = 0; i < 0x5ffff; i++); //second portion of process

*AT91C_PIOB_ODSR ^= (1 << 0); //Blink
}
}

__task void task2(void)
{
int i = 0;
while(1){
for (i = 0; i < 0x6ffff; i++); //first portion of process
for (i = 0; i < 0x6ffff; i++); //second portion of process

*AT91C_PIOB_ODSR ^= (1 << 1); //Blink
}
}

__task void task3(void)
{
while(1){
os_dly_wait(50);
*AT91C_PIOB_ODSR ^= (1 << 2); //Blink
}
}

Task3 رو اضافه کردم که اولویتش 2 هست. یعنی از task1 و task2 اولویت بیشتری داره. تو این تسک فقط عمل چشمک زدن انجام میشه. با شروع به کار سیستم عامل، task3 که بالاترین اولویت رو داره اجرا میشه. در ابتدای این تسک تابع os_dly_wait با ورودی 50 فراخوانی میشه. یعنی می خوام به اندازه 50 تیک تو اجرای این تسک تاخیر ایجاد کنم. با توجه به اینکه زمان هر تیک رو 10 میلی ثانیه مشخص کردم، این تاخیر میشه 500 میلی ثانیه. خب بعد از اجرای این تابع، سیستم عامل این تسک رو به حالت معلق در میاره تا زمان تاخیرش تموم بشه و برگرده تسک رو ادامه بده. نکته مهم اینه که تو این زمان وقت پردازنده تلف نمیشه. سیستم عامل میره تسک های با اولویت بیشتر رو اجرا میکنه. یعنی تو این زمان task1 و task2 که اولویت برابری دارن بطور همزمان اجرا میشن. به محض اینکه زمان تاخیر برای task3 تموم شد، ادامه این تسک بدون مزاحمت هیچ تسک دیگه ای اجرا میشه. دستور بعدش اجرا میشه و دوباره به wait میرسه... اگه دقت کنین عمل چشمک زدن توسط task3 خیلی منظم انجام میشه. این بخاطر اینه که اولویت بالاتری داره و به محض اینکه زمان تاخیرش به اتمام برسه، فورا اجرا میشه.
task3 رو تغییر بدین:

__task void task3(void)
{
int i = 0;
while(1){
os_dly_wait(50);
for (i = 0; i < 0x9ffff; i++); //process
*AT91C_PIOB_ODSR ^= (1 << 2); //Blink
}
}

واضح که بخاطر حلقه for زمان تاخیر بیشتر میشه. فرض کنید می خوایم تسکی تعریف کنیم که به طور متناوب طی زمان دقیقی اجرا بشه. تو بحث های کنترلی همچین مواردی زیاد پیش میاد که عملی در زمان های دقیقی اجرا بشه. همین task3 با وجود حلقه for. می خوایم هربار که حلقه تسک (while) دوباره می خواد اجرا بشه 500 میلی ثانیه از شروع اجرای دفعه قبل زمان گذشته باشه. یعنی عملی می خوایم که هر 500 میلی ثانیه اجرا بشه (صرف نظر از اینکه اجرای خودش چقدر طول میکشه). ما نمی دونیم پردازش تو تسک (حلقه for) چقدر طول میکشه. بستگی به شرایط داره و موقعیت داره. ممکنه یه بار 200 میلی ثانیه طول بکشه یه بر دیگه 100 میلی ثانیه. اگه مطمئن بودیم که مثلا 100 میلی ثانیه طول میکشه، تاخیر اول تسک رو 40 (400 میلی ثانیه) تعریف میکردیم. توجه کنید که تاخیر این حلقه for رو میشه حساب کرد. اما اینو من همینطوری نوشتم. در عمل کد واقعی که برای تسک می نویسین با توجه به شرطها و ورودی ها ممکنه به شکل های مختلف اجرا بشه. ضمنا اگه تسک های هم اولویت هم داشته باشیم دیگه بدتر...
خب راه حل :
توی سیستم عامل ها (مخصوصا realtime) روش بسیار مهمی دیگه ای برای ایجاد تاخیر وجود داره. در این روش هر بار که به تابع تاخیر رسیده بشه، مدت زمان گذشته شده از فراخوانی بار قبل تابع محاسبه میشه و از تاخیر جدید کم میشه. مثلا اگه زمان تناوب رو 500 میلی ثانیه تعریف کرده باشیم و 100 میلی ثانیه از تاخیر بار قبل گذشته باشه، با رسیدن به تابع تاخیر، 400 میلی ثانیه تاخیر ایجاد میشه.
کد تسک باید اینطوری نوشته بشه:

__task void task3(void)
{
int i = 0;
os_itv_set(50);
while(1){
os_itv_wait();
for (i = 0; i < 0x9ffff; i++); //process
*AT91C_PIOB_ODSR ^= (1 << 2); //Blink
}
}

تابع os_itv_set زمان تناوب رو مشخص میکنه و os_itv_wait هم تاخیر تناوبی رو ایجاد میکنه.


موفق باشین

[raminmicro]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

خیلی ممنون
بحث خیلی خوبی رو شروع کردی و عالی داری پیش میری :applause:
چند تا سوال داشتم :nerd:
تو بخش آخر اگه اجرای تسک بیشتر از زمان تاخیر اجرای مجدد تسک طول بکشه چی میشه ؟ممکنه تسک قبل اینکه تموم بشه دوباره اجرا بشه؟

RTX RTOS به غیر مدیریت Task ها چه کارهی دیگه ای میتونه انجام بده ؟
(مثل مدیریت منابع سیستم،کار با پورتها (سریال،USB،CAN)،ایجاد رابط کاربری،ارتباط با یه حافظه و مدیریت فایلها)
یا به نوعی فقط یه هسته سیستم عامل هست و برای این که یه سیستم عامل کامل ایجاد کنیم باید خودمون اونها رو بهش اضافه کنیم ؟
ممنون
منتظر پستهای بعدی هستیم.

[spman]

پاسخ : سیستم عامل بی درنگ RTX برای ARM7/9 و Cortex-M

خدا رو شکر یکی یه سوال پرسید
کم کم داشتم شک می کردم نکنه اونقدر بد میگم که کسی هیچی نمی فهمه و دارم واسه خودم مینویسم :mrgreen:

تو بخش آخر اگه اجرای تسک بیشتر از زمان تاخیر اجرای مجدد تسک طول بکشه چی میشه ؟ممکنه تسک قبل اینکه تموم بشه دوباره اجرا بشه؟

اول باید تذکر بدم که همچین چیزی اصلا منطقی نیست. نباید تسک پریودیک اینطوری نوشته بشه.
اما خب اگه اشکالی پیش بیاد و اینطوری بشه
نه تسک که دوباره اجرا نمیشه. تابع تسک فقط یک بار اجرا میشه. اگه منظورت اینه که وسط اجرا برگرده به اونجایی که تابع تاخیر صدا زده شده، نه اینطورم نیست. برنامه طبق روال عادی اجرا میشه و بعد از اینکه به تابع تاخیر رسید، هیچ تاخیری ایجاد نمیشه. مثل یه دستوری عادی ازش رد میشه

RTX RTOS به غیر مدیریت Task ها چه کارهی دیگه ای میتونه انجام بده ؟
(مثل مدیریت منابع سیستم،کار با پورتها (سریال،USB،CAN)،ایجاد رابط کاربری،ارتباط با یه حافظه و مدیریت فایلها)
یا به نوعی فقط یه هسته سیستم عامل هست و برای این که یه سیستم عامل کامل ایجاد کنیم باید خودمون اونها رو بهش اضافه کنیم ؟

بله مدیریت منابع سیستم. یکی دیگه از مهمترین ویژگی های یه سیستم عامل که RTX هم این امکانات رو داره. اصلا مولتی تسک نوشتن بدون امکان مدیریت منابع نمیشه. هنوز وارد بحث مدیریت منابع نشدیم که مثلا وقتی چندتا تسک بخوان به منابع مشترکی دسترسی داشته باشن، باید چیکار کنیم...
RTX امکانات خوبی داره مثل پشتیباتی از شبکه CAN و TCP . اینا کتاب خونه های keil هستن. امکان مدیریت فایل هم توسط کتاب خونه FlashFS داره. احتمال زیاد در ورژن های بعدی کتاب خونه های دیگه ای هم اضافه بشه...
ضمنا یادآوری کنم هدف از همچین سیستم عاملی، این نیست که یه چیزی مثل ویندوز داشته باشیم...