MPU 6050 ile belli bir seviyede iletişim kurdum. Raw bilgileri i2c üzerinden okuyabiliyorum. Bunu Yapmamda http://harinadha.wordpress.com/2012/07/ (http://harinadha.wordpress.com/2012/07/) bu arkadaşın katkısı çok oldu.
Ayrıca Bunu Usart tan BT aracılığıyla PC ye gönderiyorum.
Şimdi diyeceksiniz ki "Arkadaş ne gerek var buna zaten yapmışsın" ama amacım RTOS denilen nirvana ya ulaşmak. Bunu CoOS (http://www.coocox.com/CoOS.htm (http://www.coocox.com/CoOS.htm)) ile yapmayı planlıyorum.
(Bu arada Ramazan Ve Ben Haftaya İzine ayrılıyorum. Sabaha Kadar Ne Yapacagız?)
Şu an Raund Robin (Benim İçin Raundlar şeklinde Geçiyor :) )Çalışmayı deniyorum. Basit ve zor değil anladığım kadarıyla, Çünki CoOS nin nasıl yazıldığını değil Nasıl Kullanacağımı Öğrenmeye Çalışıyorum.
Sorum Şu Herhangi bir Taskın Süresini belirleyebiliyor muyum ?
Örneğin TaskA 10ms
TaskB 3ms gibi
Yoksa Hepsi 10Ms oluyor ama işlemi bittiğinde sıradaki task a mı atlıyor ?
Aşağıda 3 task olan bir örneği çalıştırdım. ama anlamadığım konu şu oldu
CoTimeDelay(0,0,1,0); // Delay 1 second
ile 1 saniye bekle diyorum. bu esnada sıradaki task a gidiyor mu gitmiyormu ? gidiyor gibi geldi bana.
Böyle bir durumda her taskın kesin zamanını nereden bileceğim ?
Saat ta 5:44 olmuş
/*---------------------------- Include ---------------------------------------*/
#include <CoOS.h> /*!< CoOS header file */
#include "stm32f4xx.h"
GPIO_InitTypeDef GPIO_InitStructure;
/*---------------------------- Symbol Define -------------------------------*/
#define STACK_SIZE_TASKA 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKB 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKC 128 /*!< Define "taskA" task size */
/*---------------------------- Variable Define -------------------------------*/
OS_STK taskA_stk[STACK_SIZE_TASKA]; /*!< Define "taskA" task stack */
OS_STK taskB_stk[STACK_SIZE_TASKB]; /*!< Define "taskB" task stack */
OS_STK taskC_stk[STACK_SIZE_TASKC]; /*!< Define "taskB" task stack */
void initGPIO()
{
{
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
}
void taskA (void* pdata) {
for (;;){
GPIO_ToggleBits(GPIOD, GPIO_Pin_12);
//CoTickDelay(1);
CoTimeDelay(0,0,1,0); // Delay 1 second
}
}
void taskB (void* pdata){
for (;;){
int i;
i = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0);
GPIO_WriteBit(GPIOD,GPIO_Pin_13,i);
CoTickDelay(10);//Delay 10 SystemTick
}
}
void taskC (void* pdata){
for (;;){
GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
CoTimeDelay(0,0,0,300); // Delay 300 milisecond
}
}
int main(void)
{
SystemInit();
initGPIO();
CoInitOS (); /*!< Initial CooCox CoOS */
/*!< Create three tasks */
CoCreateTask (taskA,0,0,&taskA_stk[STACK_SIZE_TASKA-1],STACK_SIZE_TASKA);
CoCreateTask (taskB,0,1,&taskB_stk[STACK_SIZE_TASKB-1],STACK_SIZE_TASKB);
CoCreateTask (taskC,0,1,&taskC_stk[STACK_SIZE_TASKC-1],STACK_SIZE_TASKC);
CoStartOS (); /*!< Start multitask */
while(1)
{
}
}
mesaj birleştirme:: 28 Temmuz 2013, 06:03:30
1 saniyede bir bu işi yap gibi bir şey sanırım .
Hocam ben daha önceden CMSIS RTX RTOS çalıştırdım. Orada taskların sonuna eklenen osDelay() fonksiyonu ile her taska kaç saniye(milisaniye) gelineceği belirtiliyordu. Yani task sonunda yazan süre kadar sonra tekrar geri geliniyor.
Coos ile Keilin kendi Rtos u arasında terimsel olarak pek fark olmasa gerek. Muhittin hocam bende bu işin takipçisiyim. Şuanda git gide Rtos un kendi yapısına sürükleniyorum.
Bazı Sormak istediklerim var.
1-) Bir Task En fazla nekadar sıklıkla çağrılabilir? Örneğin Ben timer kullanarak 800uS aralıklarla kesme oluşturabiliyorum. Mesela Kesme yerine Herhangi bir Rtos Taskını bu işe yönlendirebilirmiyim. Buradaki sınır nedir?
2-) Rtos Kullanıldığı zamanlar Timer kesmeleri çalışırmı, Yani Rtos Tasklarının dışında yine Timer kesmesi veya başka herhangi bir kesme kullanabilirmiyim?
3-) Örneğin Ben bir task ın max işlem süresini 3ms yaptım. Program bu taskın içerisindebir yere takılıp 3ms den fazla kalması gerekirse başka bir task çalıştırabilirmiyim. Yani taskda bir bekleme olursa başka bir taskı devreye sokup önlem alayım.
4-) En fazla kaç adet task oluşturabilirim?
Daha soracağım çok Soru var fakat şimdilik aklıma bunlar geldi. En Fazla merak ettiklerim bunlar
Soru bana gelmese de deneyimlerime dayanarak bildiklerim(ya da bildiğimi zannettiklerimi yanlışlarım varsa düzeltelim) dahilinde açıklamaya çalışayım.
1-Öncelikle RTOS ile bir bakıma yazılımsal olarak kesme oluşturmuş gibi oluyoruz.Yani timer kesmesi ile yapmak istediğiniz herşeyi uygun delay koyarak yaptırabiliriz.
2-Timer kesmeleri de çalışır.Ben denemedim.Ama ben CAN kesmesi çalıştırdım.Dikkat edilmesi gereken nokta kesmenin threadler arası geçişini bozmamak için kesme içinde fazla takılmadan bayrağını temizleyip, kendi kesme threadimi yazdım. Kesmeden bir signal yollayarak kesme threadini aktif ettim.Kesme den sonra threa yine pasif yaptım.Çalıştırdım CAN Kesmesini.
3-Eğer bir task yapılırken başka bir taskın süresi dolar ise izinler ve öncelikler dahilinde diğerine gider işini yapar ve geri dönüp kaldığı yerden devam eder.
4-Ben RTX ile 7 thread çalıştırdım.Daha da olabilir.
Mucit Diğerlerine Vakıf değilim ayhan cevaplamış.
CoOS de DelayTick vermiş ve herbir tick i 10ms ye ayarlamış görünüyor.
CoOS da verilen örneği incelediğimde 3 Task yapmış ama ben koplaya yapıştır 4 task yaptım. Sonrasında CoOSConfig dosyasında MaxUserTAsk Adında bir değişkenin 5 olarak tanımlandığını gördüm. [deneyip bakacağım kaça kadar gidiyor. (Murada Muhtemelen yapılan Task_stack boyutu önemli)]
Aklıma Takılan Bir Konuyu Sorayım.
taskA()
.....
.....
Falanfilan
Delay (10) // her 10ms de buraya gel (Eğer değilse lütfen uyarınız.)
EndTAskA
taskB()
.....
.....
Falanfilan
Delay (10) // her 10ms de buraya gel (Eğer değilse lütfen uyarınız.)
EndTaskB
taskC()
.....
.....
Falanfilan
Delay (10) // her 10ms de buraya gel (Eğer değilse lütfen uyarınız.)
EndTaskC
gibi üç adet Görevim olsun.
Öncelik Sırası A,B,C.
birinci görevi bitirdi 3ms de, erken bitti. Bekliyormu ? yoksa doğrudan B ye mi gidiyor. Eğer B ye gidiyorsa "Zamanlamanın Kesinliğinden" Nasıl emin oluyoruz.
Aynısı Tersi içinde geçerli, Task için biçilen süre (Burayıda anlamadım) Geçer ama task bitmez ise (buton durumunu beklemek gibi yada ADC çevriminin bitmemesi) işlemi yarıda bırakıp sıradaki Göreve gidiyor. (Muhtemelen Tanımladığımız Stack, birdahaki çevrimde ki kullanılacak bilgileri tutuyor.) Taskların Sürelerini Nasıl Ayarlıyoruz.
Usartla Bilgi Gönderirken Kesilme Olmasını İstemem , Yada olurmu.
(Oruçtan Sanırım :D )
Sabah 5 oldu ve ben beceremedim.
2 taskım var, bunlar ADC oku ve Usart tan gönder. Adc Okuyorum Ama Usart tan Gönderemiyorum. Normal Yolla Yapıyorum.
Hatta Herhangi bir değeri de gönderemiyorum.
yatayım
Yok Gerbay anlamıyorum,
Anladığımı Anlatayım.
int AdcDeger
taskADC
...
...
Flag=1
endTask
taskUsart
waitFlag
.....
.....
endtask
burada benim yapmadığım bayrağı beklemekti. global bir değişkeni kullanmıştım.
mesaj birleştirme:: 30 Temmuz 2013, 14:25:57
Hocam Şurada Bir örnek buldum. Adam Doğrudan Yapmış
http://www.mikrocontroller.net/attachment/161617/STM32F4_Discovery_CoOS_V0202.zip (http://www.mikrocontroller.net/attachment/161617/STM32F4_Discovery_CoOS_V0202.zip)
mesaj birleştirme:: 30 Temmuz 2013, 14:52:21
birde DEBUG yaparken sıradan gitmesi gerekirken ileri geri olmadı 3 geri sonradan sıradan işletiyor komutları. garip.
mesaj birleştirme:: 30 Temmuz 2013, 14:56:55
Yukarda bahsettiğim DEBUG problemi code optimazate den kaynaklanıyormuş. none yaptım şu an düzgün debug yapıyorum.
Sonuç Olarak Okuma Yapmadan Usarttan Birşey Gönderemem, Gönderdiğimde Hatalı Olur. Bunun İçin Flag i Bekliyorum.
u32 flagID;
.
.
void taskA (void* pdata) {
for (;;){
GPIO_ToggleBits(GPIOD, GPIO_Pin_12);
CoTickDelay(10);
//CoTimeDelay(0,0,10,0);
}
}
void taskB (void* pdata){
for (;;){
int i;
i = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0);
GPIO_WriteBit(GPIOD,GPIO_Pin_13,i);
CoTickDelay(1);//Delay 1 SystemTick
if (i==1) {
CoSetFlag(flagID);
}
}
}
void taskC (void* pdata){
for (;;){
flagID = CoCreateFlag(0,0); // Reset manually, the original state is not-ready
CoWaitForSingleFlag(flagID,0);
GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
CoTimeDelay(0,0,1,0); // Delay 1 second
}
}
Hocam Şu şekilde Flag ile çalıştım.
Buradan Anlamam Gereken Şu mudur ?
flagId ye bak eğer set değilse sıradaki Task a atla. Bunun bize sağladığı avantaj ise, eğer herhangi bir görevin sonuç değeri başka bir görevi etkiliyorsa ve görev tamamlanmadığından dolayı sonucun hatalı olma olasılığı karşısında önlem almış alıyoruz.
hocam benimde aklıma yatmadı ama
http://www.coocox.org/CoOSGuide/CoOS_Semaphores.htm (http://www.coocox.org/CoOSGuide/CoOS_Semaphores.htm)
verdiği örnekte nedense taskın içerisine koymuş.
mesaj birleştirme:: 31 Temmuz 2013, 16:00:58
hocam ayrıca global alanda yapıyorum bu flag oluşturmayı nedense derlemiyor.
tamam şimdi oldu. nedense ben Task ı sonsuz döngü ile birlikte kabul etmişim. meslek icabı fazla sorgulamıyoruz zannımca. deneyelim.
mesaj birleştirme:: 31 Temmuz 2013, 16:34:06
/*---------------------------- Include ---------------------------------------*/
#include <CoOS.h> /*!< CoOS header file */
#include "stm32f4xx.h"
GPIO_InitTypeDef GPIO_InitStructure;
/*---------------------------- Symbol Define -------------------------------*/
#define STACK_SIZE_TASKA 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKB 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKC 128 /*!< Define "taskA" task size */
/*---------------------------- Variable Define -------------------------------*/
OS_STK taskA_stk[STACK_SIZE_TASKA]; /*!< Define "taskA" task stack */
OS_STK taskB_stk[STACK_SIZE_TASKB]; /*!< Define "taskB" task stack */
OS_STK taskC_stk[STACK_SIZE_TASKC]; /*!< Define "taskB" task stack */
u32 flagID;
void initGPIO()
{
{
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
}
void taskA (void* pdata) {
for (;;){
GPIO_ToggleBits(GPIOD, GPIO_Pin_12);
CoTickDelay(10);
//CoTimeDelay(0,0,10,0); // Delay 1 second
}
}
void taskB (void* pdata){
for (;;){
int i;
i = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0);
GPIO_WriteBit(GPIOD,GPIO_Pin_13,i);
CoTickDelay(1);//Delay 10 SystemTick
if (i==1) {
CoSetFlag(flagID);
}
}
}
void taskC (void* pdata){
for (;;){
CoWaitForSingleFlag(flagID,0);
GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
CoTimeDelay(0,0,1,0); // Delay 1 second
}
}
int main(void)
{
SystemInit();//168mhz
initGPIO();
CoInitOS (); /*!< Initial CooCox CoOS */
flagID = CoCreateFlag(0,0); // Reset manually, the original state is not-ready*******************************************
/*!< Create three tasks */
CoCreateTask (taskA,0,0,&taskA_stk[STACK_SIZE_TASKA-1],STACK_SIZE_TASKA);
CoCreateTask (taskB,0,1,&taskB_stk[STACK_SIZE_TASKB-1],STACK_SIZE_TASKB);
CoCreateTask (taskC,0,1,&taskC_stk[STACK_SIZE_TASKC-1],STACK_SIZE_TASKC);
CoStartOS (); /*!< Start multitask */
while(1)
{
}
}
mesaj birleştirme:: 31 Temmuz 2013, 16:35:00
amacım butonu kontrol ederek diğer taskı sıraya almak. herhalde bu doğru oldu..
şimdi Usart ile bilgi göndereyim.
mesaj birleştirme:: 31 Temmuz 2013, 16:52:26
Hocam Yukarda Verdiğim Kodda ise şöyle bir durum gerçekleşti. Birkez bayrağı set ettiğimde ve task sıraya girdiğinde devamlı çalışıyor.
mesaj birleştirme:: 31 Temmuz 2013, 16:55:58
flagID = CoCreateFlag(Bool AutoReset,Bool initial state);
de parametre olarak veriliyormuş buna bağlı olarak
flagID = CoCreateFlag(1,0); yapınca her task bitiminde bayrağı sıfırlıyor sanırım.
Gerbay Hocam Sizi yakaladığım iyi oldu,
Flag i anladım. Peki Mutex nedir ? Neden Kullanırız ?
@Gerbay
Uzun zamandir sormak istedigim bir soru vardi. Keilin kendisininkinden baska, multitasking yapan cekirdek kodlar kullaniyor olalim.
Tasklardan birisinde y=sin(x) gibi bir fonksiyon olsun.
Diger taskda da g=sin(x) olsun.
sin fonksiyonunu donanimsal değil de yazilimsal olarak cok uzun kodlardan olusan programla hesaplayan C komutunu kullanmis olalim.
1. task sin islemine baslayip bitiremedigi bir sirada task gecisi olsun ve 2. task gene sin islemini yapmaya calissin.
Keil sin isleminde sapitirmi? Keil'in C fonksiyonlari boyle durumlarin ustesinden gelecek sekilde mi yazilmistir?
Alıntı YapKeil sin isleminde sapitirmi? Keil'in C fonksiyonlari boyle durumlarin ustesinden gelecek sekilde mi yazilmistir?
multithreaded/multitasking sistemlerde ortak kutuphanelerin re-entrant olmasi gerekir.
Bunu cesitli mekanizmalar ile garanti edebilirsiniz.
yani sin fonksiyonu iki ayri task tarafindan ayni anda kullanilabilir.
Keildeki durumu biliyormusunuz?
Keil'de multitasking uygulamalari yapilabiliyor. Bu durumda kendi cekirdegimizi yazdigimizi varsayarsak C fonksiyonlarinin tamamini gonul rahatligiyla kullanabilirmiyim?
Cesitli mekanizmalar derken ne demek istediniz?
Dos zamaninda bu buyuk problemdi. Dos mesgul ise DOS intlari kullanmiyor mesgul durumun bitmesini bekliyorduk.
Buna benzer bir yapidanmi bahsediyorsunuz? Evet ise Keil'de boyle bir flag varmi?
Alıntı YapKeildeki durumu biliyormusunuz?
irrelevant (tam turkcesini yazmak zor, belki bu sorunuzun cevabinin konu ile alakasi yok denebilir)
Alıntı YapBu durumda kendi cekirdegimizi yazdigimizi varsayarsak
yazdiginiz cekirdeginizin her durumda calistigindan eminseniz o zaman konusuruz.
Alıntı YapCesitli mekanizmalar derken ne demek istediniz?
sayin @z prensip olarak kullanci adinda kendi gercek isim/soyadini kullanmayan/kullanmaktan cekinen ve de (ornegin) re-entrant denince bu ne imis diye arastirma yapmak yerine vaktim yok, senin vaktin cok/degersiz eseklik etmede cevap diyen arkadaslara vs cevap yazmiyorum. Ama yanlis tahmin etmiyorsam sizin yasiniza, tecrubenize ve bazi konularda yapmaya calistiginiz detayli ve derinlemesine calismalara olan saygimdan bu prensibimi bir kereye mahsus olarak bozuyorum.
http://en.wikipedia.org/wiki/Reentrancy_%28computing%29 (http://en.wikipedia.org/wiki/Reentrancy_%28computing%29) bahsinden cimbizla cekersek:
genel tanim olarak:
Alıntı YapIn computing, a computer program or subroutine is called reentrant if it can be interrupted in the middle of its execution and then safely called again ("re-entered") before its previous invocations complete execution. The interruption could be caused by an internal action such as a jump or call, or by an external action such as a hardware interrupt or signal. Once the reentered invocation completes, the previous invocations will resume correct execution.
Rules for reentrancy basligindanda:
Alıntı Yap
Reentrant code may not hold any static (or global) non-constant data.
Reentrant functions can work with global data. For example, a reentrant interrupt service routine could grab a piece of hardware status to work with (e.g. serial port read buffer) which is not only global, but volatile. Still, typical use of static variables and global data is not advised, in the sense that only atomic read-modify-write instructions should be used in these variables (it should not be possible for an interrupt or signal to come during the execution of such an instruction).
Reentrant code may not modify its own code.
The operating system might allow a process to modify its code. There are various reasons for this (e.g., blitting graphics quickly) but this would cause a problem with reentrancy, since the code might not be the same next time.
It may, however, modify itself if it resides in its own unique memory. That is, if each new invocation uses a different physical machine code location where a copy of the original code is made, it will not affect other invocations even if it modifies itself during execution of that particular invocation (thread).
Reentrant code may not call non-reentrant computer programs or routines.
Multiple levels of 'user/object/process priority' and/or multiprocessing usually complicate the control of reentrant code. It is important to keep track of any access and or side effects that are done inside a routine designed to be reentrant.
Ingilizceden Turkceye tercume yapmak konusunda ise bir istisna yapmaya niyetim yok. Bilgisayar, electronic vb teknolojik konulara hakim olmak icin en az bir yabanci dili akici olarak bilmek zorundayiz.
Alıntı YapDos zamaninda bu buyuk problemdi. Dos mesgul ise DOS intlari kullanmiyor mesgul durumun bitmesini bekliyorduk.
DOS benim universiteden mezun olup profesyonel hayatima atildiktan 5 sene sonra tanistigim basit bir kontrol programi idi. O siralarda (uzun bir sure) PClere oyuncak gozuyle bakilmisti. O yuzden dedikleriniz dogrudur.
Alıntı YapBuna benzer bir yapidanmi bahsediyorsunuz?
Hayir, adinda OS(operating system) kelimesi gecmesine ragmen DOS bir isletim sistemi değildir.
DOS tek kullanici ve single-tasking non-reentrant bir kontrol programi/API dir.
Hocam Sıkıyorsam eğer Kusruma Bakmayın.
void myTaskA(void* pdata)
{
mutexID = CoCreateMutex ( );
CoEnterMutexSection(mutexID ); // enter the mutex section
........... // critical codes
CoLeaveMutexSection(mutexID ); // leave the mutex section
}
void myTaskB(void* pdata)
{
CoEnterMutexSection(mutexID ); // enter the mutex section
........... // critical codes
CoLeaveMutexSection(mutexID ); // leave the mutex section
}
örneğini vermiş. Tanımlanan yapını elemanlarına Ulaşmak İçin CoOS CoLeaveMutexSection(mutexID ) yi görmek zorunda. Yoksa CoEnterMutexSection(mutexID ); de bekliyor ve sıradaki göreve devrediyor işlem sırasını. Böyle Anlıyorum.
Ekleme
Peki Mutexle yapacağım işlemi Flag ilede yapabiliyorken neden Mutex ?
Mufitsozen hocam,
Dos zamaninda evet multi tasking isler yoktu ama bir tusa basinca hereket etmeye baslayan tabiri yerindeyse o anki taski tamamen durdurup bir diger taski baslatan kodlar yazabiliyorduk. O yuzden benzetme yaptim.
veritabanı işlemlerinde bilgi güncellenirken diğer kullanıcılar için kilitleme işlemi yapılırdı, onun gibi birşey.
taskın içerisinden fonksiyon çağırabiliyor muyuz ?
çünki ne yaptıysam Usarttan Bilgi gönderemedim.
Alıntı yapılan: z - 01 Ağustos 2013, 02:23:46
Mufitsozen hocam,
Dos zamaninda evet multi tasking isler yoktu ama bir tusa basinca hereket etmeye baslayan tabiri yerindeyse o anki taski tamamen durdurup bir diger taski baslatan kodlar yazabiliyorduk. O yuzden benzetme yaptim.
TSR denilen, ve basa bela cikartmaktan baska bir ise yaramayan kucuk programlardan bahsediyorsunuz zannederim.
Bende rs232 den bilgi okuma, zamanla ilgili bir takim uygulamalar ve ozel I/O kartlarimi kullanmak icin TSR ve yuklenen programlarla haberlesmek icin int 2f (multiplex) mekanizmasini kullanan 5-6 uygulama yazmistim. sonradan DESQview gibi bazi multitasking programlari cikmistida DOS altinda iki is yapacagiz diye sacimizi sakalimizi yolmaktan kurtulmustuk.
Keil in bir fonksiyonu var. Ve bunun thread safe olduğunu bilmiyorsanız illa da kullanacağım diyorsanız bunu da critical section içinde bir anda tek task kullanacak şekilde yazabilirsiniz.
MySinFunction(x)
{
beginCritialSection
sin(x);
endCritialSection
}
Taslarınız içinde MySinFunction fonksiyonunu kullanınız.
Bu konularda benim kafama takılan bir soru var.
mutex ile binary semaphore arasında fark nedir?
Hocam adım adım gitmeyi planlıyorum, Önce Flasg, Mutex Semaphore ve diğer konular.
tasklar arası geçiş için
void taskB (void* pdata){
for (;;) {
CoWaitForSingleFlag(flagID,0);
USART_puts(USART2,str);// "Init complete! Hello World!rn");
CoTickDelay(1)
}
}
de bekleme koymak zorundamıyız, eğer kaldırırsam diğer task a geçmiyor.
hocam flagla alakalı değil hiç flag olmasa dahi bekleme olmadığında task geçişi olmuyor.
Alıntı yapılan: muhittin_kaplan - 02 Ağustos 2013, 16:49:30
hocam flagla alakalı değil hiç flag olmasa dahi bekleme olmadığında task geçişi olmuyor.
sayin @muhittin_kaplan bence cevap yazmadan once @gerbayin mesajini arada dusunerek 5 kere daha okuyup irdelemeye calisiniz. :P
5 kez irdeledim ama
Geybay ın bahsettiği flag ile alakalı olarak,
"eğer flag ile blokladığın task ı atlayıp diğer task a sıradaki task a geçmiyorsa" demiş, (geçmiş konuşmalardan dolayı) bende bunun üzerine flag ile alakalı olmayıp delay koymadığım hiçbir taskı bırakmıyor dedim.
atladığım nokta nedir, hatalı yaptığım mı, zaten hatalı yaptığımdan dolayı düzgün çalışmıyor.
Alıntı yapılan: muhittin_kaplan - 02 Ağustos 2013, 17:38:11
5 kez irdeledim ama
Geybay ın bahsettiği flag ile alakalı olarak,
"eğer flag ile blokladığın task ı atlayıp diğer task a sıradaki task a geçmiyorsa" demiş, (geçmiş konuşmalardan dolayı) bende bunun üzerine flag ile alakalı olmayıp delay koymadığım hiçbir taskı bırakmıyor dedim.
atladığım nokta nedir, hatalı yaptığım mı, zaten hatalı yaptığımdan dolayı düzgün çalışmıyor.
sayin @muhittin_kaplan, tam 10 dakikadir yazip birseyler aciklamaya calismistimki, yanlis bir tusa bastim, hepsi uctu! :(
yarin vaktim olursa size biraz detayli cevap yazmaya calisacagim
mesaj birleştirme:: 02 Ağustos 2013, 18:28:43
Write Short ISR's:
- Even lowest priority ISR's are handled before the highest priority task code (minimize task code response time)
- ISR's are error prone and hard to debug (due to hardware-dependent software parts)
- Parts ISR code requiring immediate / quick response should be in the core of ISR code; parts needing 'longer' processing and not-so-urgent response should be done a task (signaled by the ISR)
-Recommended Task Structure
-Modeled/Structured as State-Machines –
-Tasks run in an infinite loop
-Tasks wait on RTOS for an event (expected in each task's independent message queue)
-Tasks declare their own private data to use (fully encapsulated)
-Tasks block on in one place (RTOS signal), and not any other semaphore, no data sharing
-Tasks use no microprocessor time when their queues are empty
-Avoid Creating and Destroying Tasks
-Creating tasks takes more system time
-Destroying tasks could leave destroy pointers-to-messages, remove semaphore others are waiting on (blocking them forever)
-Rule-of-thumb: Create all tasks needed at start, and keep them
Bu kisa liste sizin prblemlerinze cevap verecektir.
mesaj birleştirme:: 02 Ağustos 2013, 18:39:27
cok kucuk ve yetersiz bir ornek ama, soyle bir set-top-box tasklari olabilir(mi ki acaba? :P )
Task 1:
Read Signal
Separate Audio/Video
Send Audio to Task 2
Send Video to Task 3
Repeat
Task 2:
Wait on Task 1
Decode/output Audio
Repeat
Task 3:
Wait on Task 1
Decode/output Video
Repeat
lutfen producer/consumer modeli vb gibi arayarak daha formal bir tasarim aciklamasi bakiniz.
hocam zahmet veriyorum farkındayım, hakkınızı helal edin, kusruma bakmayın artık. belkide aptalca bir yerde takılıyor önümdekini görmüyorum. yada kafa bu kadar basmıyor.
http://www.bilgisayarkavramlari.com/2012/03/05/producer-consumer-problem-uretici-tuketici-problemi/ (http://www.bilgisayarkavramlari.com/2012/03/05/producer-consumer-problem-uretici-tuketici-problemi/)
Hocam Olayı Anladım, Burada bir problem yok,
Taskın birindeki bir değişim diğerini etkiliyorsa, değişim olana kadar beklemeli.
ama benim uğraştığım problem task switching yapmaması, birbirini etkileyen durumlar yokken.
Aşağıdaki Kodlarda taslar arası geçiş sağlanırken
/*---------------------------- Include ---------------------------------------*/
#include <CoOS.h> /*!< CoOS header file */
#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
/*---------------------------- Symbol Define -------------------------------*/
#define STACK_SIZE_TASKA 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKB 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKC 128 /*!< Define "taskA" task size */
/*---------------------------- Variable Define -------------------------------*/
OS_STK taskA_stk[STACK_SIZE_TASKA]; /*!< Define "taskA" task stack */
OS_STK taskB_stk[STACK_SIZE_TASKB]; /*!< Define "taskB" task stack */
OS_STK taskC_stk[STACK_SIZE_TASKC]; /*!< Define "led" task stack */
void initGPIO()
{
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
}
/**
*******************************************************************************
* @brief "taskA" task code
* @param[in] None
* @param[out] None
* @retval None
* @par Description
* @details This task use to crate mutex and flags,print message "taskA running".
* Indicate "taskA" had been executed.
*******************************************************************************
*/
void taskA (void* pdata) {
unsigned int led_num;
for (;;) {
GPIO_ToggleBits(GPIOD, GPIO_Pin_12);
CoTickDelay (50);
}
}
/**
*******************************************************************************
* @brief "taskB" task code
* @param[in] None
* @param[out] None
* @retval None
* @par Description
* @details This task use to print message "taskB running". Indicate "taskB"
* had been executed.
*******************************************************************************
*/
void taskB (void* pdata){
unsigned int led_num;
for (;;) {
GPIO_ToggleBits(GPIOD, GPIO_Pin_13);
CoTickDelay (50);
}
}
/**
*******************************************************************************
* @brief "taskB" task code
* @param[in] None
* @param[out] None
* @retval None
* @par Description
* @details This task use to print message "taskB running". Indicate "taskB"
* had been executed.
*******************************************************************************
*/
void taskC (void* pdata){
unsigned int led_num;
for (;;) {
GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
CoTickDelay (50);
}
}
int main(void)
{
initGPIO();
CoInitOS (); /*!< Initial CooCox CoOS */
/*!< Create three tasks */
CoCreateTask (taskA,0,0,&taskA_stk[STACK_SIZE_TASKA-1],STACK_SIZE_TASKA);
CoCreateTask (taskB,0,1,&taskB_stk[STACK_SIZE_TASKB-1],STACK_SIZE_TASKB);
CoCreateTask (taskC,0,2,&taskC_stk[STACK_SIZE_TASKC-1],STACK_SIZE_TASKC);
CoStartOS (); /*!< Start multitask */
while(1)
{
}
}
Bu Kodlarla Yapmıyor.
/*---------------------------- Include ---------------------------------------*/
#include <CoOS.h> /*!< CoOS header file */
#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
/*---------------------------- Symbol Define -------------------------------*/
#define STACK_SIZE_TASKA 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKB 128 /*!< Define "taskA" task size */
#define STACK_SIZE_TASKC 128 /*!< Define "taskA" task size */
/*---------------------------- Variable Define -------------------------------*/
OS_STK taskA_stk[STACK_SIZE_TASKA]; /*!< Define "taskA" task stack */
OS_STK taskB_stk[STACK_SIZE_TASKB]; /*!< Define "taskB" task stack */
OS_STK taskC_stk[STACK_SIZE_TASKC]; /*!< Define "led" task stack */
void initGPIO()
{
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
}
/**
*******************************************************************************
* @brief "taskA" task code
* @param[in] None
* @param[out] None
* @retval None
* @par Description
* @details This task use to crate mutex and flags,print message "taskA running".
* Indicate "taskA" had been executed.
*******************************************************************************
*/
void taskA (void* pdata) {
unsigned int led_num;
for (;;) {
GPIO_ToggleBits(GPIOD, GPIO_Pin_12);
}
}
/**
*******************************************************************************
* @brief "taskB" task code
* @param[in] None
* @param[out] None
* @retval None
* @par Description
* @details This task use to print message "taskB running". Indicate "taskB"
* had been executed.
*******************************************************************************
*/
void taskB (void* pdata){
unsigned int led_num;
for (;;) {
GPIO_ToggleBits(GPIOD, GPIO_Pin_13);
}
}
/**
*******************************************************************************
* @brief "taskB" task code
* @param[in] None
* @param[out] None
* @retval None
* @par Description
* @details This task use to print message "taskB running". Indicate "taskB"
* had been executed.
*******************************************************************************
*/
void taskC (void* pdata){
unsigned int led_num;
for (;;) {
GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
}
}
int main(void)
{
initGPIO();
CoInitOS (); /*!< Initial CooCox CoOS */
/*!< Create three tasks */
CoCreateTask (taskA,0,0,&taskA_stk[STACK_SIZE_TASKA-1],STACK_SIZE_TASKA);
CoCreateTask (taskB,0,1,&taskB_stk[STACK_SIZE_TASKB-1],STACK_SIZE_TASKB);
CoCreateTask (taskC,0,2,&taskC_stk[STACK_SIZE_TASKC-1],STACK_SIZE_TASKC);
CoStartOS (); /*!< Start multitask */
while(1)
{
}
}
aralarındaki tek fark task sonlarında delay olmaması (delay da değildir ya :p)
Bu cevabi yazarken ornek verdiginiz prgramlari compile edip denemedim onun icin yaniliyorda olabilirim ama son 30 dakikada kucuk bir inceleme yapinca sanki prbleminizin ne oldugunu buldum.
sayin @muhittin_kaplan delay olmayan programdaki task priorityleri 0,1,2 yerine hepsini ayni yapiniz ki time-tick interrupt gelince siradaki ayni prioritydeki taske gecilsin.
Orneginizin kisitli/kotu olmasindan dolayi kafaniz karisiyor ve size @gerbay yada benim soylediklerimle gozlemleriniz celisiyor gibi geliyor. (su-i misal emsal olmaz yani :P )
affiniza dayanarak bir kere daha soylemem gerek. RTOS ile ilgili conceptleri bilmeden yapilan deneme yanilma ile ogrenmeniz hem zaman alacak hemde burada goruldugu gibi size yanlis intiba/aliskanliklar verecek. Bahsettiginiz (problem olmayan) problem CoOSun isleyisinden geliyor.
Benim okuduguma ve incelememe gore:
ilk programinizda (delay olan) delay yapinca task ready den cikiyor, siradaki en yuksek oncelikli ready diger task devreye geliyor ve taskler arasinda gecis oluyor
ikinci programinizda 3 task birden ready ve oncelikleri de farkli, dolayisi ile hep en yuksek oncelikli task calisiyor.
CoOS user guide sayfa 18de soyle soyluyor.
2.5 Task Scheduling
CooCox CoOS supports two kinds of scheduling mode, preemptive priority
and round-robin. The former is used among tasks of different priority, while the
latter among tasks of the same priority.
CooCox CoOS will start a task scheduling in the following three situations:
1) A task whose priority is higher than the current running one is
converting to the ready state;
2) The current running task is changing from the running state to the
waiting or dormant state;
3) A task sharing the same priority with the current running task is in the
ready state, and meanwhile the time slice of the current task runs out .
When a system tick interrupt exits or some tasks' states have changed,
CooCox CoOS will call the task scheduling function to determine whether it is
essential to start a task scheduling or not.
For the scheduling of tasks sharing the same priority, the system starts the
rotation scheduling according to the time slice of each task. When the system
has run out the time slice of the current task, it will give the right of control to
the next task with the same priority
isterseniz ozelden mesaj atip mbl telefonunuzu verirseniz size yardimci olmak isterim
hocam bu task önceliğini ben yanlış anlamışım. öncelik derken anladığım bir nevi sıralama idi. ama dediğiniz doğru tasların önceliğini aynı yapınca şuan doğrudan geçiş yapıyor.
Cep telefonundan zor olmaz mı bu ?
Saygıyla
Alıntı yapılan: muhittin_kaplan - 03 Ağustos 2013, 02:12:07
hocam bu task önceliğini ben yanlış anlamışım. öncelik derken anladığım bir nevi sıralama idi. ama dediğiniz doğru tasların önceliğini aynı yapınca şuan doğrudan geçiş yapıyor.
Cep telefonundan zor olmaz mı bu ?
Saygıyla
Benim her yanlis anladigim konu icin sen otur yarim saat programlari incele/karsilastir, dokuman oku, neyi yanlis anladigimi bul diyorsunuz yani.
Haklisiniz, evet cep telefonundan cok zor olur. Pahalida olur ustelik.
Bol sans. Saygilar.
Bana Haksızlık Ediyorsunuz Hocam, Sadece Flag i Kavramak için Defalarca CoOS yi inceledim, Kaldıkı Mesaj Yazdığım Saatlere Bakarsanız Üzerinde Ne Kadar Durduğumu Anlarsınız.
Saygıyla..
Alıntı yapılan: muhittin_kaplan - 03 Ağustos 2013, 03:33:33
Bana Haksızlık Ediyorsunuz Hocam, Sadece Flag i Kavramak için Defalarca CoOS yi inceledim, Kaldıkı Mesaj Yazdığım Saatlere Bakarsanız Üzerinde Ne Kadar Durduğumu Anlarsınız.
Saygıyla..
Yine cok haklisiniz.
Sizin bu yogun calismalariniz sirasinda caninizi sikmak istememistim.
Ilerlemis zamanin (neredeyse gece 4 olmus) yasli bir zihine oynattigi oyun diyelim.
Ozur dilerim.
Hocam Özre Gerek Yoktur,
Durduğum Yeri Bilen Biriyim, Sizin Nazarında Diğer Hocaların Karşısında Saygılı olmamız gerekir. Eksiklerimiz vardır elbet. Bunları da Sizler affedin.
Mümkün Olduğunca Paylaşırım. Belkide Bu "Hayatımı Bu İşten Kazanmıyor" olmamdan kaynaklıdır.
Saygıyla.
mesaj birleştirme:: 03 Ağustos 2013, 04:07:26
Unutmadan Espri ile karışık, Saat 20 gibi Bana Kızdığınızı Farketmiş diğer konuya Yapıştırmışım (Araştırmadan Soruyor algısı oluştuğunu hissetmiştim.)
https://www.picproje.org/index.php/topic,48120.msg358795.html#msg358795 (https://www.picproje.org/index.php/topic,48120.msg358795.html#msg358795)
Şurada iğrenç bir müzikle bir video verilmiş, bu video da preemptive priority yi anltmış ve bazı chartlar çıkartmış,
www.youtube.com/watch?v=c-DuS9iYkWc (http://www.youtube.com/watch?v=c-DuS9iYkWc#)
buradaki burst time nedir
diye araştırınca task için gerekli olan süre olduğunu anlıyorum, peki task için gerekli süreyi nasıl bileceğim ?
mesaj birleştirme:: 06 Ağustos 2013, 05:37:08
ROUND ROBIN SCHEDULING ALGORITHM (http://www.youtube.com/watch?v=GjrxO-PDPdk#)
Muhittin hocam genel konsept için şu kitabın e-kitabını indirin aklınıza takılan birçok soruya cevap olacaktır:
http://www.amazon.com/Embedded-Multitasking-Technology-Keith-Curtis/dp/0750679182 (http://www.amazon.com/Embedded-Multitasking-Technology-Keith-Curtis/dp/0750679182)
Alıntı Yap.....task için gerekli olan süre olduğunu anlıyorum, peki task için gerekli süreyi nasıl bileceğim ?
sayin @muhittin_kaplan hocam, siz bilmeyeceksinizde bizmi bilecegiz? :D
Saka bir yana bu sure sizin gereksinimlerinizin (requirements) size dikte ettirdigi sure.
Ornegin her 5 msde bir ADC okunup bilgisayara gonderilecek. yada saniyede 100 sample islenecek vb
tabii buradaki sureler cok siki (tight) değil. oyle olsaydi hard-real-time bir sistem olurdu, tasarimida daha zor olurdu (radar, savas sistemleri, vb)
Normal olarak ticari sistemlerde gereksinimler x zamanda bir +-%y diye olur.
Ornegin benim tecrubeli oldugum VoIP sistemlerde acceptable round-trip delay 200ms'dir kullanicilar bu deger 250-300msyi gecerse farki algilayabilmeye baslarlar. yani round-trip delay icin gereksinim 200ms +-50 ms olsa kabul edilebilir limitlerde olur.
Yok Hocam Kastım Taskın Süresi Değil. (1tick 10ms olarak ayalanmış CoOs da-http://coocox.org/CoOSguide/CoOS_System_Ticks.htm-) Onu ben belirliyorum OS un parametreleriyle.
Oluşturduğum bir task ne kadar sürede işlem yapar ? (belkide yanlış sorular soruyorum, bu yüzden doğru cevabı bulamıyorum.)
Dolayısıyla BirTaskın işlemini bitirmesi TaskSüresi+RoundTrip değilmidir.
mesela bir Gyrodan bilgi okumam gereksin (zaman önemli) ve ben RoundRobin kullanayım. taskA nın işlemini bitrme süresini nereden bileceğim.
void taskA (void* pdata) {
for (;;) {
s16 AccelGyro[6]={0};
MPU6050_GetRawAccelGyro(AccelGyro);
AccX=AccelGyro[0];
AccY=AccelGyro[1];
AccZ=AccelGyro[2];
GyrX=AccelGyro[3];
GyrY=AccelGyro[4];
GyrZ=AccelGyro[5];
sprintf(str,"GX%dGY%dGZ%dAX%dAY%dAZ%dS\r\n",GyrX,GyrY,GyrZ,AccX,AccY,AccZ);
USART_puts(USART2,str);
CoSetFlag(flag0);
}
}
void taskB (void* pdata){
for (;;) {
CoTickDelay(10);
}
}
void taskC (void* pdata){
for (;;) {
CoWaitForSingleFlag(flag0,0);
GPIO_ToggleBits(GPIOD,GPIO_Pin_12);
//CoTickDelay(1);
GPIO_ToggleBits(GPIOD,GPIO_Pin_13);
//CoTickDelay(1);
GPIO_ToggleBits(GPIOD,GPIO_Pin_14);
//CoTickDelay(1);
GPIO_ToggleBits(GPIOD,GPIO_Pin_15);
CoTickDelay(5);//5*10ms=50ms de bir bu işlemi gerçekleştir mi oluyor ?
}
}
Herseyden once belirtmem lazimki, ben CoOS expert'i değilim. onun icin yazdiklarim tam dogru olmiyabilir
Ayrica tam olarak ne yapmak istediginiz sizce belirli ama, bizim bu konuda cok flu bir fikrimiz var
Tam olarak ne yapmak istediginizi soylerseniz ona gore dusunuruz.
ustelik acik bir forumda sadece mesajlasarak kisitli ortamin dezavantajlarindan dolayi yanlis anlasilmalarda cok olacaktir.
simdi kaide olarak taskler bir event vb ile uyanip birsey yapip tekrar beklemeli, vede taskler arasinda mesajlar ile haberlesilmeli dedik.
Ayrica hw ile ilgili konularda ISR yapip, onlarida tasklere IPC teknikleri ile baglamak lazim diye daha once yazmistik.
Simdi sizin gyrodan okumanizin sadece periodik bir timer ile yapildigini (ornegin gereksiniminizin, her 10msde bir gyrodan okuma yapmak ve bunu PCye gondermek oldugunu oldugu varsayalim.
PCye olan iletisim, RS232 olacak ve buda bir ISR ile kontrol edilecek. Bu ISR rs232den gelen ve giden karakterleri bir message queue'sundan alacak.
Gyro icin bir ISR gerekmiyor, dogrudan okuma yapilabilir varsayiyoruz.
o zaman (bence) taskler soyle olur:
taskA:
10 msde bir gyroyu oku,
sonuclari taskBye queue et
10msde bir calisma kisminida bir periodik timer yapip, while loop icinde onu bekleyip, sonra gyroyu okuyarak yapabilirsiniz.
yani
taskA:
/* tanimlari yap */
/* initializationlar: periodik timer icin kullanacaginiz semaphore'u yaratin */
/* periodik 10ms timer baslat: call_back fonksiyonunda bu timer ile ilgili olan ve timerin expire oldugunu gosteren semaphonu set eden fonksiyonu belirtin)
while (1){
timer_semaphorunu bekleyin,
semaphoru reset edin (timeri islediginiz icin)
gyro_degerlerini okuyun
degerleri rs232 taskine queue edin
}
gibi bir yapida yapabilirsiniz
timeriniz periodik oldugu icin, siz bu islemleri yaparken yine 10m sayacaktir.
boylece her 10ms+x milisaniyede (x=minik bir miktar interrupt latency ve semaphore set edilmesi vb icin fix bir zaman degeri ki, bu epsilon gibi birsey olacaktir, microsaniyeler mertebesinde olur.)
yada call_back fonksiyonunda semaphore set filanlaugrasmayip, direk gyro degerlerini okuyup rs232 taskine queue edebilirsiniz.
Benim kisisel tercihim, bu sekilde yapilirsa, call_back fonksiyonlarinin ne zaman cagrildigi ve program execution'i karisik olur hatalara yol acar, bu yuzden call_back fonksiyonlarinida cok kucuk ve kisitli bir fonksiyon yapmak icin kullanmak dahah dogru olur diye dusunuyorum.
birde taskB yapacaksiniz, kendi queue'una gelen karakterleri alip PCye yolliyacak.
(vede belki PCden gelenleride ISR ile alip, baska bir taskC ye yolliyacak, yada rs232 ISR gelen datayi taskCye queue edecek, ne bileyim ben :))
nerede kalmıştık. ;)