اطلاعیه

Collapse
No announcement yet.

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

Collapse
این موضوع برجسته شده است.
X
X
 
  • فیلتر
  • زمان
  • Show
Clear All
new posts

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

    .....
    با یک سری ملاحظات میشه این کد رو برای سیستم شبیه سازی کننده بازنویسی کرد. البته نه همش رو. بلکه روال های سطح پایه رو.
    مثلا:

    تابع os_sem_init رو در نظر بگیرین. یک مثال از شرکت ARM:


    #include <rtl.h>

    OS_SEM semaphore1;

    void task1 (void) __task {
    .
    .
    os_sem_init (semaphore1, 0);
    os_sem_send (semaphore1);
    .
    .
    }


    اولا در هدر مربوطه OS_SEM باید معادل با HANDLE تعریف بشه.
    os_sem_init میتونه یک تابع باشه. اما چون نام سمافور به عنوان پارامتر پاس شده OS_SEM رو باید بفرم HANDLE[1] تعریف کرد. بعد میشه روال های مربوطه رو اینجوری نوشت (در سورس جایگزین rtx):


    void os_sem_init (
    OS_ID semaphore, /* The semaphore object to initialize */
    U16 token_count ) /* Initial number of tokens */
    {
    if(semaphore)
    *semaphore = CreateSemaphore(NULL, token_count, 65535L, NULL);
    }

    OS_RESULT os_sem_send(OS_ID semaphore)
    {
    if( semaphore )
    ReleaseSemaphore( *semaphore, ...);
    return OS_R_OK;
    }

    OS_RESULT os_sem_wait(OS_ID semaphore, U16 timeout)
    {
    if(!semaphore) return OS_R_OK;
    if(WaitForSingleObject(*semaphore, (timeout == 0xFFFFU) ? INFINITE : timeout))==WAIT_OBJECT_0)
    return OS_R_OK;
    return OS_R_TMO;
    }


    بنظر میاد مجبور باشیم اغلب سورس های RTX رو دوباره بازنویسی کنیم. ولی خیلی از سورس ها احتیاجی به بازنویسی ندارن.
    ....

    دیدگاه


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

      حالا اگر بیاییم این تعریفات رو در یک هدر تصحیح شده بنام rtx بذاریم و برنامه رو کامپایل کنین. میبینین که هم کامپایل میشه و هم میشه براحتی اجراش کرد.
      فقط چند تا مورد سیستمی باقی میمونه. یکی اینکه اینجا نمیشه وقفه ها رو فعال و غیر فعال کرد. ولی میشه یک mutex در ابتدای کار گرفت که برای غیر فعال کردن یا فعال کردن وقفه ها در حالت سیمولیشن؛ این mutex رو گرفت و آزاد کرد.

      وقف ها رو هم که عمدتا میشه با استفاده از یک سری thread شبیه سازی کرد.

      برای ایجاد عملیات IO من معمولا یک سری روال برای ارسال و دریافت اطلاعات از طریق پورت ها مینویسم و اگر این اطلاعات منجر به ایجاد ساختاری بشه که بشه بطور گرافیکی نشونش داد با یک برنامه #C یک محیط معادل ایجاد میکنم و ارتباط بین اون محیط و برنامه رو از طریق همین روال ها برقرار میکنم.

      دیدگاه


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

        آقا رضا اومد من دیگه تو این تاپیک حرفی واسه گفتن ندارم! :mrgreen:

        من هنوز متوجه نشدم چرا باید اینکارو بکنیم؟ سیمولاتورهایی مثل خود سیمولاتور کیل اکثر امکانات سخت افزاری رو پشتیبانی میکنن. یعنی ما میتونیم دقیقتر پیاده سازی کنیم؟

        اگه بخوایم خیلی دقیق کار کنیم، بحث زمانبندی تو شبیه سازی خیلی پیچیده میشه. مثل درنظر گرفتن زمان های دلتا (قبل از زمان صفر)

        نوشته اصلی توسط reza_agha
        .....
        با یک سری ملاحظات میشه این کد رو برای سیستم شبیه سازی کننده بازنویسی کرد. البته نه همش رو. بلکه روال های سطح پایه رو.
        مثلا:

        تابع os_sem_init رو در نظر بگیرین. یک مثال از شرکت ARM:


        #include <rtl.h>

        OS_SEM semaphore1;

        void task1 (void) __task {
        .
        .
        os_sem_init (semaphore1, 0);
        os_sem_send (semaphore1);
        .
        .
        }


        اولا در هدر مربوطه OS_SEM باید معادل با HANDLE تعریف بشه.
        os_sem_init میتونه یک تابع باشه. اما چون نام سمافور به عنوان پارامتر پاس شده OS_SEM رو باید بفرم HANDLE[1] تعریف کرد. بعد میشه روال های مربوطه رو اینجوری نوشت (در سورس جایگزین rtx):


        void os_sem_init (
        OS_ID semaphore, /* The semaphore object to initialize */
        U16 token_count ) /* Initial number of tokens */
        {
        if(semaphore)
        *semaphore = CreateSemaphore(NULL, token_count, 65535L, NULL);
        }

        OS_RESULT os_sem_send(OS_ID semaphore)
        {
        if( semaphore )
        ReleaseSemaphore( *semaphore, ...);
        return OS_R_OK;
        }

        OS_RESULT os_sem_wait(OS_ID semaphore, U16 timeout)
        {
        if(!semaphore) return OS_R_OK;
        if(WaitForSingleObject(*semaphore, (timeout == 0xFFFFU) ? INFINITE : timeout))==WAIT_OBJECT_0)
        return OS_R_OK;
        return OS_R_TMO;
        }


        بنظر میاد مجبور باشیم اغلب سورس های RTX رو دوباره بازنویسی کنیم. ولی خیلی از سورس ها احتیاجی به بازنویسی ندارن.
        ....
        اینا که همش تغییر کردن! فقط قسمت win32 رو نوشتین؟

        با این کدها اگه بخوایم منطق برنامه رو شبیه سازی کنیم بله باید جواب بده. اما بنظرم زمان ها به شدت از حالت واقعی دور میشن. حالا اگه برنامه تحت سیستم عامل مثل RTX نوشته شده باشه که scheduler نقش حیاتی تو روند اجرای برنامه داره چی میشه...

        آقا رضا بیشتر توضیح بده. مثال عملی...
        https://www.linkedin.com/in/mohammadhosseini69

        http://zakhar.blog.ir

        دیدگاه


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

          سیمولاتور کیل که فقط رجیسترها رو نشون میده :sad:
          اگه قضیه زمانبندی و شبیه سازی دقیق RTX حل بشه فرض کن N96 LCD یا MMC یا Ethernet تو ویندوز شبیه سازی بشه.

          دیدگاه


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

            نوشته اصلی توسط رامین جعفرپور
            سیمولاتور کیل که فقط رجیسترها رو نشون میده :sad:
            موقع دیباگ منوی perioherals رو باز کن. میشه پریفرال ها رو کنترل کرد.

            نوشته اصلی توسط رامین جعفرپور
            اگه قضیه زمانبندی و شبیه سازی دقیق RTX حل بشه فرض کن N96 LCD یا MMC یا Ethernet تو ویندوز شبیه سازی بشه.
            آره شبیه سازی اینا خوبه

            میگم آقا رضا حالا که قدم رنجه فرمودید تو این تاپیک، لطفا زحمت اشتباهات پست ها قبلی که احیانا از روی جوونی و نادونی مرتکب شدم بکشین و من و بقیه دوستان رو از جهل مرکب نجات بدین! (مثل تاپیک winavr)
            https://www.linkedin.com/in/mohammadhosseini69

            http://zakhar.blog.ir

            دیدگاه


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

              نوشته اصلی توسط محمد حسینی
              موقع دیباگ منوی perioherals رو باز کن. میشه پریفرال ها رو کنترل کرد.
              اینارو دیدم.
              منظورم شبیه سازی سخت افزراهای جانبی مثل LCD ها و Keypad و ... هست.چون پروتئوس متاسفانه برای ARM به جز یه سری خاص هیچکدومو ساپورت نمیکنه . با این کار میشه ضعف پروتئوس رو جبران کرد و حتی سخت افزارهای بهتری نسبت به لایبرلی ایجاد کرد.
              تو خود پروتئوس هم از همین WinPcap برای شبیه سازی آی سی انترنت استفاده کردن.

              دیدگاه


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

                تطفا کرک keil RL-ARM برای ورژن اخر 4.21 را بگذارید(کرک MDK-ARM با RL-ARM فرق دارد و دو محصول در این ورژن یکی شده است)

                دیدگاه


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

                  عرضم اینه:

                  وقتی شما سراغ یک پروسسوری با سرعت 30 مگاهرتز به بالا میرین عمدتا کارتون طوریه که عملیات منطقی یا محاسباتی بالایی دارین یعنی کارتون بیشتر بر انجام عملیات کاری استوار هست؛ و نه ورودی و خروجی.
                  در اینجور مواقع عمدتا وقتی پای بعضی کارها پیش میاد انجام اون کار مهمتره از اینکه بگین آیا این کار دقیقا 10 میلی ثانیه ای تموم میشه یا 10.35 میلی ثانیه. مثلا دارین یک فایل رو از روی MMC میخونین و به پورت سریال ارسال میکنین. درسته که سرعت پردازش میکرو خیلی توی کار تاثیر داره اما روی یک میکروی خاص کسی گیر نمیده که چرا این کار 12 میلی ثانیه طول کشید و 11.5 میلی ثانیه نشد. البته مسلما اگر 1 میلی ثانیه طول میکشید بهتر بود ولی اجباری نیست. ولی مسلما اگر 20 ثانیه طول بکشه بدرد نمیخوره.

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

                  نمونه اش چشمک زدن یک LED با فرکانس 2 هرتز. یعنی هر 250 میلی ثانیه یک تغییر وضعیت داشته باشیم. حالا اگر این زمان تغییر شد 235 میلی ثانیه یا 280 میلی ثانیه اصلا چشم متوجه نمیشه که بخواد کسی گیر بده. یعنی من به ازای نیاز خاصی دارم یک میزان دقتی رو حروم میکنم. و این هم مهم نیست.

                  حالا شما مدل سخت افزاریتون رو روی پروتئوس پیاده میکنین. میتونین عمده سخت افزارتون رو روی پروتئوس چک کنین. اما وقتی با یک منطق هشل هفت سروکار دارین شبیه سازی روی پروتئوس هم ممکنه دردی رو دوا نکنه. علاوه بر این که پروتئوس محدودیت های بسیار بیشتری نسبت به یک برنامه قابل اجرا روی ویندوز داره. با اینکه با همچین روشهایی نمیشه سخت افزار نهایی رو تماما تست کرد. ولی با ایجاد سخت افزاری مشابه با سخت افزار ایده آل نهایی میشه میزان ایرادات بالقوه برنامه رو حداقل کرد و با امکاناتی بیشتر یک منطق بزرگ رو راحتتر تست کرد.

                  نمیدونم منظورم رو میگیرین یا نه (راسیتش خودم هم گیج شدم)

                  دیدگاه


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

                    دیدگاه


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

                      سلام به همه دوستان.
                      آقای محمد حسینی خیلی ممنون از آموزش های عالیتون. :applause: ولی چرا دیگه ادامه نمیدین؟

                      دیدگاه


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

                        سلام

                        وقت... !! نمی دونم چیکار کنم! همیشه هزارتا کار واسه خودم درست میکنم. هیچ کدومم کامل انجام نمیشه! :mrgreen:
                        فعلا فرصت نوشتن ندارم.
                        اما
                        یه داکیومنت در مورد راه اندازی شبکه CAN با پشتیبانی RTX نوشتم. اون یه ویرایشی میکنم میذارم حالش ببرین!
                        https://www.linkedin.com/in/mohammadhosseini69

                        http://zakhar.blog.ir

                        دیدگاه


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

                          به نام خدا
                          پیاده سازی شبکه CAN با میکروکنترلر AT91SAM7X256 و سیستم عامل بلادرنگ RTX

                          CAN (مخفف Controller Area Network) یک باس استاندارد است که برای برقراری ارتباط بین واحدهای کنترل الکترونیکی (ECU) درون یک خودرو طراحی شده و پراستفاده ترین پروتکل در طراحی و ساخت قسمت های ارتباطی وسایل نقلیه است. امروزه CAN بخاطر قابلیت هایی که دارد، در انواع پروژه ها و محیط های صنعتی نیز استفاده می شود.
                          CAN یک پروتکل مبتنی بر پیام (message based) و multi-master broadcast سریال است. شبکه CAN می تواند شامل تعداد زیادی Node باشد که هر Node قابلیت ارسال و دریافت اطلاعات را دارد. هر پیام شامل یک ID و حداکثر 8 بایت داده است. وسایل (device) های متصل شده به CAN، عموما حسگرها (sensor)، محرک ها (actuator) و دیگر تجهیزات کنترلی هستند.
                          ویژگی ها :
                          - پرسرعت (تا 1Mbps)
                          - قابلیت اولویت بندی پیام ها، مناسب برای طراحی سیستم بلادرنگ (پیام با شماره ID پایین تر دارای اولویت بالاتر است)
                          - باس 2 سیمه تفاضلی (2-wire differential bus)
                          - ایمنی بسیار زیاد در برابر نویز
                          - قابلیت خطایابی، کنترل و رفع خطا (در مواقع تداخل و ...)
                          - استاندارد ISO 11898 در لایه Data link و قسمت هایی از لایه فیزیکی

                          برای پیاده سازی، هر Node به موارد زیر نیاز دارد :
                          - Host processor
                          o پردازنده تصمیم می گیرد که هر پیام دریافتی چه معنایی دارد و با توجه به پیام چه عملی باید صورت گیرد. همینطور وظیفه تصمیم گیری در مورد پیام هایی که باید ارسال شوند به عهده این قسمت است. کاربر با برنامه نویسی پردازنده، سیستم مورد نظر را کنترل میکند. sensorها و actuatorها به پردازنده متصل می شوند.
                          - CAN controller
                          o وظیفه دریافت : CAN controller بیت ها را بصورت سریال از باس دریافت می کند تا یک پیام کامل فراهم شود. سپس پیام به Host processor منتقل می شود.
                          o وظیفه ارسال : Host processor بیت های ارسالی را در CAN controller ذخیره می کند تا پیام را بشکل سریال ارسال کند.
                          - Transceiver
                          o وظیفه تبدیل سطوح سیگنال بین باس و CAN controller را به عهده دارد. باس ایجاد شده توسط Transceiver یک باس دو سیمه تفاضلی است. سیگنال های این باس CAN_H و CAN_L نام دارند.


                          میکرو کنترلر AT91SAM7X256 (مبتنی بر پردازنده ARM7-TDMI) دارای یک CAN controller می باشد. این کنترلر دارای هشت Mailbox (یا Channel) است. هر Mailbox می تواند هربار تا حداکثر 8 بایت داده را ارسال یا دریافت کند. دو Frame مهم CAN عبارتند از Data frame و Remote frame. Data frame برای ارسال داده و Remote frame برای درخواست داده استفاده می شود. با ارسال Remote frame، کنترلر مقصد (بدون درگیر کردن پردازنده) بطور خودکار داده درخواستی که توسط کاربر مشخص شده را ارسال می کند. فریم ها دارای یک identifier می باشند. این ID برای Standard frame ها 11 بیت وبرای Extended frame ها 29 بیت می باشد.
                          از آی سی MCP2551 می توان به عنوان Transceiver استفاده کرد. دو سر باس CAN باید توسط مقاومت های 120 اهمی به هم متصل شوند تا جریان نسبتا بالایی در باس ایجاد شده و مقاومت باس در برابر نویز زیاد شود.


                          برای آشنایی با پیاده سازی این شبکه، مداری مانند شکل زیر با 4 node بسته شد. هرکدام از میکروکنترلرها، توسط تراشه MCP2551 ، به عنوان یک Node به باس CAN متصل هستند. میکرو کنترلرهای 1 ، 2 و 3، هر 300 میلی ثانیه، یک ورودی ADC را خوانده و با یک پیام دو بایتی برای میکروکنترلر4 ارسال می کنند. میکروکنترلر4 که منتظر دریافت اطلاعات است، بعد از دریافت هر پیام، اطلاعات دریافتی از هر node را روی LCD همراه با شماره node نمایش می دهد. همزمان node شماره 4 نیز می توان برای node های دیگر اطلاعات ارسال کرده و فرمان مناسب را صادر کند. عملیات ارسال و دریافت به شکل تسک های جدا توسط سیستم عامل RTX نوشته شده است.


                          RL-RTX یک هسته سیستم عامل بلادرنگ تحت محیط توسعه KEIL MDK برای پردازنده های ARM7TDMI ، ARM9 و CORTEX-M3 است. توسط این سیستم عامل می توان بسادگی یک سیستم بلادرنگ شامل تسک های اولویت بندی شده طراحی کرد. پشتیبانی از پروتکل بلادرنگ CAN (library RL-CAN) از جمله ویژگی های مهم این سیستم عامل است.
                          https://www.linkedin.com/in/mohammadhosseini69

                          http://zakhar.blog.ir

                          دیدگاه


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

                            RL-CAN

                            فایل های کتابخانه RL-CAN :
                            RTX_CAN.h : این فایل شامل تعریف توابع و ثابت ها است.
                            RTX_CAN.c : توابع عمومی کنترلر CAN. این فایل با فایل CAN_chip.c که پیاده سازی قسمت سخت افزار کنترلر است ارتباط بر قرار می کند.
                            CAN_chip.c : با توجه به میکروکنترلر مورد استفاده باید یکی از فایل های مربوط استفاده شود. (CAN_SAM7X.c در این پروژه)
                            CAN_CFG.h : فایل پیکربندی کنترلر CAN


                            برای ارسال و دریافت فریم ها از نوع داده CAN_msg که به شکل زیر تعریف شده است استفاده می شود.

                            typedef struct {
                            U32 id; /* 29 bit identifier */
                            U8 data[8]; /* Data field */
                            U8 len; /* Length of data field in bytes */
                            U8 ch; /* Object channel */
                            U8 format; /* 0 - STANDARD, 1 - EXTENDED IDENTIFIER */
                            U8 type; /* 0 - DATA FRAME, 1 - REMOTE FRAME */
                            } CAN_msg;

                            توابع CAN_init و CAN_start برای راه اندازی کنترلر CAN فراخوانی می شوند.

                            CAN_ERROR CAN_init (
                            U32 ctrl, /* CAN Controller */
                            U32 baudrate); /* Baudrate */

                            CAN_ERROR CAN_start (
                            U32 ctrl); /* CAN Controller to Enable */

                            CAN_rx_object برای پیکربندی یک Mailbox(channel) در حالت دریافت استفاده می شود.

                            CAN_ERROR CAN_rx_object (
                            U32 ctrl, /* CAN Controller */
                            U32 channel, /* CAN Channel Number */
                            U32 id, /* Message ID */
                            U32 object_para); /* Object Parameters */

                            CAN_receive فریم ارسال شده به Mailbox را دریافت می کند. پارامتر سوم تابع، زمانی را برای انتظار دریافت فریم مشخص می کند. در صورتی که 0xFFFF انتخاب شود، این زمان نامحدود می شود. لازم به ذکر است که این زمان تلف نمی شود. با وجود سیستم عامل، زمان پردازش در اختیار تسک های دیگر قرار می گیرد.

                            CAN_ERROR CAN_receive (
                            U32 ctrl, /* CAN Controller */
                            CAN_msg *msg, /* CAN Message */
                            U16 timeout); /* Time to Wait */
                            CAN_send : ارسال داده
                            CAN_ERROR CAN_send (
                            U32 ctrl, /* CAN Controller */
                            CAN_msg *msg, /* CAN Message */
                            U16 timeout); /* Time to Wait */
                            CAN_request : ارسال Remote frame
                            CAN_ERROR CAN_request (
                            U32 ctrl, /* CAN Controller */
                            CAN_msg *msg, /* CAN Message to Request */
                            U16 timeout); /* Time to Wait */

                            CAN_set : پیکربندی یک Mailbox برای پاسخ خودکار به Remote frame

                            CAN_ERROR CAN_set (
                            U32 ctrl, /* CAN Controller */
                            CAN_msg *msg, /* CAN Message */
                            U16 timeout); /* Time to Wait */


                            نمونه برنامه :

                            __task void tsk_send(void)
                            {
                            int i = 0;
                            CAN_msg msg_buf2 = {
                            33, // ID
                            { 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00 }, // Data
                            2, // Length
                            2, // Channel
                            STANDARD_FORMAT, // Format
                            DATA_FRAME // Type
                            };

                            AT91S_ADC *pADC = AT91C_BASE_ADC;
                            pADC->ADC_CR = AT91C_ADC_SWRST; //reset
                            pADC->ADC_MR |= AT91C_ADC_LOWRES_8_BIT | (0x3<<24);
                            pADC->ADC_CHER = AT91C_ADC_CH4;

                            os_itv_set(30);
                            while(1){
                            pADC->ADC_CR = AT91C_ADC_START;
                            while (pADC->ADC_SR & AT91C_ADC_EOC4 == 0); //End of Conversion
                            adc_data = (unsigned int) pADC->ADC_CDR4 & AT91C_ADC_DATA;

                            msg_buf2.data[0] = 'A';
                            msg_buf2.data[1] = adc_data;
                            CAN_send(1, &msg_buf2, 0xffff);
                            os_itv_wait();
                            }
                            }

                            این تسک هر 300 میلی ثانیه اطلاعات ADC را خوانده و ارسال می کند. شماره ID 33 و Mailbox 1 با طول 2 بایت.

                            CAN_rx_object(1, 2, 33, DATA_TYPE | STANDARD_TYPE);
                            __task void tsk_receive(void)
                            {
                            CAN_msg msg_buf;

                            while(1){
                            CAN_receive (1, &msg_buf, 0xffff);
                            if (msg_buf.data[0] == 'A&#039{
                            lcd_gotoxy(1,3);
                            lcd_putsf(" "
                            lcd_gotoxy(1,3);
                            lcd_puts(msg_buf.data[1]);
                            }
                            else if (msg_buf.data[0] == 'B&#039{
                            lcd_gotoxy(1,11);
                            lcd_putsf(" "
                            lcd_gotoxy(1,11);
                            lcd_puts(msg_buf.data[1]);
                            }
                            else if (msg_buf.data[0] == 'C&#039{
                            lcd_gotoxy(2,3);
                            lcd_putsf(" "
                            lcd_gotoxy(2,3);
                            lcd_puts(msg_buf.data[1]);
                            }
                            }
                            }

                            تسک دریافت برای فریم داده استاندارد. Mailbox 2 با ID 33 .
                            https://www.linkedin.com/in/mohammadhosseini69

                            http://zakhar.blog.ir

                            دیدگاه


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

                              مطالبی که از نظر مبارکتون گذشت، داکیومنت اولیه برای پروژه ای بود که مثلا قرار بود اولین پروژه ای باشه که رسما برای جایی انجام میدم و پول میگیرم!!
                              اما نیومدن دنبالش! استاد راهنما هم دنبالش نرفت!
                              خلاصه ترم6 هم سپری شد و بعد این همه دود چراغ خوردن همچنان بخت یاری نمیکنه و هنوز یه نصف پروژه هم انجام ندادم. تا کی خودناباوری...! :mrgreen:
                              یکی که پیش خدا مقام و جایگاه در حد آسمون دوم سوم به بالا داره یه دعایی واسه ما بکنه ...

                              پست اول باید 3 تا تصویر داشته باشه. اگه نشون نمیده بگین یه جا دیگه پلود کنم.
                              این فایل pdf دو تا پست قبل
                              http://spiderman.persiangig.com/micro/can.pdf

                              این دوتام ببینین خوبه
                              http://spiderman.persiangig.com/micro/AT91SAM7%20-%20CAN.ppt
                              http://spiderman.persiangig.com/micro/Can%20bus.pdf

                              دیتاشیت SAM7X بخش CAN رو هم حتما بخونین. در مورد mailbox و channel و همه اینا توضیح داده. البته واسه برنامه نویسیش توابع RTX کافی هستن.
                              https://www.linkedin.com/in/mohammadhosseini69

                              http://zakhar.blog.ir

                              دیدگاه


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

                                خدا خیرت بده آقای حسینی. یه چند تا سوال راجع به پست های اولتون داشتم
                                اگه تسک دوم اولویت 2 داشته باشه و تسک اول اولویت 1 داشته باشه. و توی تسک ها یه حلقه for که cpu رو مشغول کنه گذاشتیم واسه درست کردن تاخیر. حالا سوال من اینه تسک دوم که اولویتش بیشتره همیشه توی حلقه for میمونه و پایه پورت رو یک میکنه وحالا کی میره به تسک اول؟؟!!
                                یا یجور دیگه بگم یه تسک با اولویت بالا کی تموم میشه و اجازه میده که تسک های با اولویت پایین تر شروع به کار کنن؟ در حالی که یه حلقهfor داره و همیشه آماده اجراست
                                ببخشید سوالم خیلی مبتدیه امیدوارم حوصله جواب دادنشو داشته باشید :rolleyes:

                                دیدگاه

                                لطفا صبر کنید...
                                X