traceTASK_INCREMENT_TICK() - Apelata din rutina de traceTASK_SUSPEND(pxTask) - Apelata din vTaskSuspend.

tratare a intreruperii ceasului de timp real. traceTASK_RESUME(pxTask) - Apelata din vTaskResume.

traceTASK_SWITCHED_OUT() - Apelata înainte de a preda traceTASK_RESUME_FROM_ISR(pxTask) - Apelata din
procesorul unui task după o replanificare; xTaskResumeFromISR.
pxCurrentTCB - conţine handlerul la taskul care predă
procesorul. in freeRTOS:
traceTASK_SWITCHED_IN() - Apelata dupa ce procesorul este
predat unui task, la replanificare; #define configUSE_TRACE_FACILITY 1
pxCurrentTCB - conţine handlerul la taskul care preia procesorul. #define traceTASK_SWITCHED_OUT() vMainMineOut()
traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue) - Indica #define traceTASK_SWITCHED_IN() vMainMineIn()
dacă taskul in curs de excutie este pe cale sa treacă in starea blocat //#define INCLUDE_xTaskGetCurrentTaskHandle 1
la citirea dintr-o coadă goală sau solicitarea accesului la un
semafor/mutex ocupat. cateva functii
traceBLOCKING_ON_QUEUE_SEND(pxQueue) - Indica dacă uxTaskPriorityGet( xHandle )
taskul in curs de excutie este pe cale sa treacă in starea blocat la vTaskPrioritySet( xHandle, 1 );
scrierea într-o coadă plină. vTaskSuspend( xHandle );
traceGIVE_MUTEX_RECURSIVE(pxMutex) - Apelata din vTaskResume( xHandle );
xSemaphoreGiveRecursive. ----
traceQUEUE_CREATE(pxQueue) - Apelata din xQueueCreate struct AMessage{
– succes. portCHAR ucMessageID;
traceQUEUE_CREATE_FAILED() - Apelata din xQueueCreate portCHAR ucData[ 20 ]} xMessage;
– esec (memorie heap insuficienta).
traceCREATE_MUTEX(pxMutex) - Apelata din xQueueHandle xQueue1, xQueue2;
xSemaphoreCreateMutex – caz mutexul creat cu succes. xQueue1 = xQueueCreate( 10, sizeof( unsigned portLONG ) );
traceCREATE_MUTEX_FAILED() - Apelata din if( xQueue1 == 0 ){
xSemaphoreCreateMutex la esec (memorie heap insuficienta) // Queue was not created and must not be used.}
traceGIVE_MUTEX_RECURSIVE(pxMutex) - Apelata din
xSemaphoreGiveRecursive pe succes.
traceGIVE_MUTEX_RECURSIVE_FAILED(pxMutex) - xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
Apelata din xSemaphoreGiveRecursive – esec (taskul solicitanr nu struct AMessage *pxMessage;
a fost proprietarul mutexului). if( xQueueSend( xQueue2, &pxMessage, ( portTickType ) 10 ) ==
traceTAKE_MUTEX_RECURSIVE(pxMutex) - Apelata din pdPASS ){s-a trimis mesajul}
xQueueTakeMutexRecursive.
traceCREATE_COUNTING_SEMAPHORE(pxSem) - Apelata struct AMessage *pxRxedMessage;
din xSemaphoreCreateCounting – succes. !!!if( xQueueReceive( xQueue, &( pxRxedMessage ), (
traceCREATE_COUNTING_SEMAPHORE_FAILED() - portTickType ) 10 ) ){}
Apelata din xSemaphoreCreateCounting la esec (memorie heap
insuficienta). traceQUEUE_SEND(pxQueue) - Apelata din void vQueueDelete( xQueueHandle xQueue );
xQueueSend, xQueueSendToFront, xQueueSendToBack, etc –
succes. traceQUEUE_SEND_FAILED(pxQueue) - Apelata din traceQUEUE_CREATE(pxQueue),
xQueueSend, xQueueSendToFront, xQueueSendToBack, esec traceQUEUE_CREATE_FAILED()
(coada plina). traceQUEUE_RECEIVE(pxQueue) - Apelata din traceQUEUE_DELETE(pxQueue)
xQueueReceive, etc – succes. traceQUEUE_SEND(pxQueue),
traceQUEUE_RECEIVE_FAILED(pxQueue) - Apelata din traceQUEUE_SEND_FAILED(pxQueue)
xQueueReceive, etc - în caz de esec – coadă goală. traceQUEUE_RECEIVE(pxQueue),
traceQUEUE_PEEK(pxQueue) - Apelata din xQueuePeek. traceQUEUE_RECEIVE_FAILED(pxQueue),
traceQUEUE_SEND_FROM_ISR(pxQueue) - Apelata din traceQUEUE_PEEK(pxQueue)
xQueueSendFromISR - succes. traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue),
traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue) - traceBLOCKING_ON_QUEUE_SEND(pxQueue)
Apelata din xQueueSendFromISR – esec (coada plina). --------
traceQUEUE_RECEIVE_FROM_ISR(pxQueue) - Apelata din xSemaphoreHandle xSemaphore;
xQueueReceiveFromISR - succes. xSemaphore = xSemaphoreCreateBinary();
traceQUEUE_RECEIVE_FROM_ISR_FAILED(pxQueue) - xSemaphore = xSemaphoreCreateMutex();
Apelata din xQueueReceiveFromISR în caz de esec – coadă goală.
traceQUEUE_DELETE(pxQueue) - Apelata din vQueueDelete. if( xSemaphoreTake( xSemaphore, ( portTickType ) 10 ) ==
traceTASK_CREATE(pxTask) - Apelata din xTaskCreate daca pdTRUE ){
taskul este creat cu succes. xSemaphoreGive( xSemaphore );}
traceTASK_CREATE_FAILED() - Apelata din xTaskCreate take e receive, give e send
dacă taskul nu este creat cu success, din cauză ca nu exista traceCREATE_COUNTING_SEMAPHORE(pxSem),
traceCREATE_COUNTING_SEMAPHORE_FAILED()
memorie heap suficientă
traceCREATE_MUTEX(pxMutex), traceCREATE_MUTEX_FAILED()
traceTASK_DELETE(pxTask) - Apelata din vTaskDelete. traceGIVE_MUTEX_RECURSIVE(pxMutex),
traceTASK_DELAY_UNTIL() - Apelata din vTaskDelayUntil. traceGIVE_MUTEX_RECURSIVE_FAILED(pxMutex) (alt propritar solicita acces
recursiv) traceTAKE_MUTEX_RECURSIVE(pxMutex)+trace de la cozi
traceTASK_DELAY() - Apelata din vTaskDelay.
traceTASK_PRIORITY_SET(pxTask,uxNewPriority) -
Apelata din vTaskPrioritySet.
1.Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33, if(xTask==hT1 && flag==1)
indicati codul C pentru a ilustra, primul cadru in care atat flag=0;}
semaforul S1 (handler hS1), cat si semaforul S2 (handler hS2) au
fost eliberate, de acelasi task, dupa ce fiecare din ele a fost ocupat void increment(XTickCount){
pentru cel putin un cadru (de catre taskul care asigura eliberarea). if(flag==1)
Accesul la S1 si S2 se face cu timeout 0. Se vor folosi facilitati numarCadre++;}
trace/hook.
3.Se considera o aplicatie dezvoltata pentru FreeRTOS si dsPIC33.
#define traceQUEUE SEND(pxQueue) f send(pxQueue); Taskul T1 (creat in main) trebuie sa asigure la fiecare 600 msec
#define traceQUEUE RECEIVE(pxQueue) f receive(pxQueue); urmatoarele functionalitati: scrie un mesaj in coada Q cu valoarea
xSemaphoreHandle hS1=NULL; numaratorului de timp real (timeout la scriere 200 msec). Apoi T1
xSemaphoreHandle hS2=NULL; scrie 1 pe PORTB10 si mentine valoarea constanta pentru 100*q
xTaskHandle hT1=NULL; msec, unde q reprezinta numarul taskurilor existente in memorie.
xTaskHandle hT2=NULL; PORTB10 trebuie tratat ca resursa pasiva partajata (semafor binar
int flag1=0; cu timeout 200 msec). Cadrul are durata de 100 msec. Scrieti codul
int flag2=0; pentru taskul T1.
portTickType t;
xTaskHandle hT1;
void f send(pxQueue){ xSemaphoreHandle hS;
if(pxQueue==hS1 && xQueueHandle Q;
xSemaphoreGiveRecursive(hS1)==pdTRUE){ void Task1 (void *param){
flag1=1; static int q:
hT1=xTaskGetCurrentTaskHandle(); //determinam taskul portTickType xLastWakeTime.msg;
curent} XLastWakeTime-xTaskGetTickCount();
if(pxQueue==hS2 && for(;;){
xSemaphoreGiveRecursive(hS2)==pdTRUE){ msg=xTaskGetTickCount();
flag2=1; xQueueSend(Q.msg,2);
hT2=xTaskGetCurrentTask Handle();} if(xSemaphoreTake(hs, 2)){
} _PORTB10=1;
q=uxTaskGetNumberOfTasks();
void f receive(pxQueue){ vTaskDelay(*q):
if(pxQueue==hS1 || pxQueue==hS2){ xSemaphoreGive(hS);}
flag1=0; vTaskDelayUntil(&xLastWakeTime, 6);}}
flag2=0;}
} 4. Pentru o aplicatie dezvoltata FreeRTOS si dsPIC33, indicate
codul C pentru a ilustra de cate ori ISR-ul numaratorului de timp
void vApplicationTickHook(void){ real intrerupe taskul B (cu handler hB). Se vor folosi facilitate
if(flag1==1 && flag2===1 && hT1==hT2){ trace/hook.
t=xTaskGetTickCount(); //aflam numarul de tick-uri} #define trace TASK_SWITCHED_OUT() void taskSwitchedOut();
else{ #define traceTASK_INCREMENT_TICK(xTickCount( void
flag1=0: traceincrement(xTickCount)));
flag2=0;} xTaskHandle hB; //handle pentru task-ul B
} unsigned char numarintreruperi = 0, flagTaskB = 0; //folosim flag-
ul sa verif. daca task-ul B preda procesorul
2. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
indicati codul C pentru a ilustra de cate ori a fost solicitata tranzitia void taskSwitchedOut(){
taskului B (cu handler hB) din starea „Suspended", solicitarea find if(pxCurrentTCB = hB){
facuta dintr-un task mai putin prioritar decat B. Se vor folosi flagTaskB = 1;}
facilitati trace/hook. }
#define traceTASK SUSPEND(XTask) TaskSuspended(xTask); void traceincrement(xTickCount){
#define traceTASK RESUM(xTask) TaskResume(xTask); if(flagTaskB==1){
#define traceTASK INCREMENT TICK(XTickCount) numarintreruperi++;} //daca task-ul B a cedat procesorul si
increment(xTickCount); imediat avem ISR t Real atunci avem conditia:
xTaskHandle hB=NULL; else
xTaskHandle hA=NULL; flagTaskB = 0; }
char flag=0;
portTickType numarCadre=0; 5. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
indicate codul C pentru a ilustra, la momentul current t (masurat
void TaskSuspended(xTask){ fata de inceputul executiei aplicatiei), in cate cadre coada de
if(xTask-=hT1 && uxTaskPriorityGet(hT1)>uxTask mesaje (cu handler Q) a avut un singur mesaj pe toata durata
PriorityGet(hT2)){ cadrului (pe durata cadrului, Q nu a avut mai mult sau mai putin de
flag=1;} 1 mesaj). Se presupune ca aceasta coada are o adancime mai mare
ca 1. Se vor folosi facilitate trace/hook.
void TaskResume(xTask){
#define traceQUEUE_SEND(XQueue) void //#define INCLUDE_xTaskGetCurrentTaskHandle 1
traceQueueSend(xQueue): In main.c:
#define traceQUEUE_RECIEVE(xQueue) void extern tskTCB * volatile pxCurrentTCB;
traceQueueRecieve(xQueue): usigned int switch_A=0;
#define traceTASK_INCREMENT_TICK(xQueue) void usigned int switch_B=0;
traceIncr(xQueue); xQueueHandle hQ: char mess;
unsigned char numarMesajeQ = 0
portTickType cadru= 0, t, momentCacruR, momentCadrus: void vBlocking(HS) {
if(hA== pxCurrentTCB)
void traceQueueSend(xQueue){ switch A++;
if(hQ== xQueue){numarMesajeQ++;) if(hB == pxCurrentTCB)
momentCadruS = xTaskGetTickCount(); switch B++;
} if(switch_A>switch B)
mess='A';
void traceQueueRecieve(xQueue){ else
if(hQ== xQueue){ numarMesajeQ--:) mess='B';}
momentCadruR == xTaskGetTickCount():
} 8. Se considera o aplicatie dezvoltata pentru FreeRTOS si
dsPIC33. Taskul T1 (creat in main) trebuie sa asigure urmatoarele
void traceincr(xQueue){ functionalitati: citeste un mesaj din coada Q, asteptand maxim 200
if(numarMesajeQ== 1 && momentCadrus == momentCadruR) { msec acces la coada. Daca citirea din coada nu a putut fi efectuata
t++;} // daca in momente egale avem un mesaj, in coada avem cu succes, T1 scrie 0 pe PORTB10 si mentine aceasta valoare
conditia constanta pentru un numar de milisecunde egal cu numarul de citiri
cadru++; esuate ale lui T1, din Q. Apoi T1 intra in blocare pentru 200 msec.
} PORTB10 trebuie tratat ca resursa pasiva partajata (semafor binar
cu timeout 10 msec). Cadrul are durata de 10 msec. Scrieti codul
6. Se considera o aplicatie dezvoltata pentru FreeRTOS si
pentru taskul T1. SemaphoreHandle S1;
dsPIC33. Taskul T1 (creat in main) trebuie sa asigure la fiecare
xQueueHandle Q1:
400 msec urmatoarele functionalitati: scrie 1 pe PORTB10 si
mentine aceasta valoare constanta pentru 200 msec. PORTB10
void T1(void *params){
trebuie tratat ca resursa pasiva partajata (semafor binar cu timeout
int mesaj;
100 msec). Apoi, T1 scrie un mesaj in coada Q. cu valoarea egala
for(;;) {
cu numarul de accesari nereusite la resursa, de pana la acel
if(xQueueReceive(Q1,&mesaj,20) == errQUEUE_EMPTY) {
moment (variabila care indica numarul de accesari nereusite la
XSemaphoreGive(S1); }
resursa va fi considerata de tip unsigned int si are valoarea 0 la
else {xQueueReceive(Q1,&mesaj,20);}
inceputul executiei aplicatiei). Cadrul are durata de 100 msec.
if(xSemaphoreTake(S1,1) == pdTRUE) {
Scrieti codul pentru taskul T1.
PORTBits.RB10 = 0;
xSemaphoreHandle hS;
vTaskDelay(20): }
xQueueHandle hQ:
vTaskDelay(20):
unsigned int accesariNereusite = 0;
}}
void Task1(void *params){
9.Se considera o aplicatie dezvoltata pentru FreeRTOS si dsPIC33.
portTickType xLastWake = xTaskGetTickCount():
Taskul T1 (creat in main) trebuie sa asigure la fiecare 800 msec
portTickType no Ticks:
urmatoarele functionalitati: scrie 0 pe PORTB10 si mentine aceasta
for(;;) {
valoare constanta pentru N*100 msec, unde N reprezinta numarul
noTicks = xTaskGetTickCount();
taskurilor din memorie. PORTB10 trebuie tratat ca resursa pasiva
if(xSemaphoreTake(hS,1) == pdTRUE){
partajata (semafor binar cu timeout 0 msec). Daca accesul la
_RB10 = 1;
resursa a fost posibil, T1 scrie un mesaj cu valoarea 0 in coada Q,
vTaskDelay(2);
altfel scrie un mesaj cu valoarea egala cu numarul de accesari la
xSemaphoreGive(hS);
resursa, efectuate cu succes pana la acel moment (variabila care
else {accesariNereusite++;}
indica numarul de accesari cu succes la resursa va fi considerata de
xQueueSend(h1, &accesariNereusite, 0):
tip unsigned int). Cadrul are durata de 100 msec. Scrieti codul
vTaskDelayUntil(&xLastWake, 4);}
pentru taskul T1.
7. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33, void T1(void *params){
indicati codul C pentru a ilustra, pana la momentul curent t unsigned portBASE_TYPE N=uxTaskGetNumberOfTasks();
(masurat de la inceputul executiei aplicatiei), care dintre taskurile static int accesari=0;
A (cu handler hA) si B (cu handler hB) a asteptat mai multe cadre for(;;){
accesul la semaforul binar S (cu handler hS). Cele doua taskuri au if(xSemaphoreTake(hs,0)==pdTrue){
timeout infinit pentru accesul la semaforul S. Se vor folosi facilitati _RB10=0;
trace/hook. accesari++;
In FreeRTOSConfig.h: xQueueSend(Q,0,portMAX_DELAY);
#define configUSE_TRACE FACILITY vTaskDelay(N*1);
#define traceBLOCKING ON QUEUE RECEIVE(pxQueue) xSemaphore Give(hS);}
vBlocking(hS) else{
xQueueSend(Q,&accesari portMAX_DELAY);} if(pxQueue==Q)
vTaskDelay(8);}} flagR=1; }
unsigned int contor =0;
10.Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33, unsigned int nrMsgPrev = 0;
indicati codul C pentru a ilustra de cate ori un taskul C (handler unsigned int nrMsgCurrent = 0;
hC) a fost sters de alt task. Se vor folosi facilitati trace/hook. void vApplicationTickHook(void) {
if(uxQueueMessagesWaiting(Q)==1 && xTaskGetTickCount()
#define traceTASK_DELETE(XTask) void traceDelete(xTask); <=t && flagR==0 && flagS==0) { nrCadru=nrCadru +1; }}
char numarStergeriTaskC=0;
void traceDelete(xTask){ 14. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
if(xTask=hC){ indicati codul C pentru a ilustra de cate ori a avut loc scrierea cu
numarStergeriTaskC++; succes a unui mesaj din taskul B (cu handler hB). Se presupune ca
}} aplicatia nu foloseste semafoare pentru partajarea resurselor
pasive. Se vor folosi facilitati trace/hook.
11.Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33, #define traceQUEUE_RECEIVE(pxQueue) fReceive();
indicati codul C pentru a ilustra de cate ori taskul C (handler hC) a unsigned int contor=0;
reusit crearea cu succes a unei cozi de mesaje. Aplicatia nu void fReceive() { If(pxQueue==hB) contor++; }
foloseste semafoare. Se vor folosi facilitati trace/hook.
15. Se considera aplicatia FreeRTOS si daPIC33. Taskul T1 creat
xQueueHandle hQ; in main, trebuie sa asigure la fiecare 800 msec urmatoarele
xTaskHandle hC; functionalitati: scrie 1 pe PORTB10 si metine aceasta valoare
#define traceTASK_CREATE(XTask); void traceCreate(xTask); constanta pentru 200 msec. PORTB10 trebuie tratat ca resursa
#define traceQUEUE_CREATE(XQueue); void pasiva partajata (semaforul binar cu timeout 100 msec). Daca
traceCreate(xQueue) accesul la resursa nu a fost posibil, T1 scrie un mesaj egal cu
char nrCreariCoadaQ=0; valoarea prioritatii sale in coada Q, altfel scrie un mesaj cu
void traceCreate(xQueue){ valoarea egala cu N, unde N este K modulo P, cu K=valoarea
if(xQueue==hQ){ numaratorului de tip real, iar P egal cu numar de taskuri existente
nrCreariCoada++; in aplicatie. Cadrul are durata de 100 msec. Scrieti codul pentru
}} taskul T1.
void Task1(void *param) {
12. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33, portTickType xLastWakeTime;
indicati codul C pentru a ilustra daca semaforul binar S (cu handler xLastWakeTime=xTaskGetTickCount();
hS) este ocupat (nu a fost inca eliberat) si un alte doua taskuri int mesaj=0;
asteapta eliberarea sa. Se vor folosi facilitati trace/hook. for( ; ; ) {
if(xSemaphoreTake(sem,1)==pdTRUE) {
#define traceBLOCKING ON QUEUE RECEIVE(hS) myblocking
(hS) _RB10=1;
vTaskDelay(2);
#define traceQUEUE RECEIVE(S) myReceive(hS) xSemaphoreGive(sem); }
unsigned int flag=0 //semafor liber else {
unsigned int nr=0; xQueueSend(Q, &mesaj,2);
mesaj=N; }
void myblocking(hS){ vTaskDelayUntil(&xLastWakeTime, 8); }
if(xTaskGetCurrentTaskHandle() == hT1){
nr++;} 16. Pentru o aplicatie dezvoltata e FreeRTOS si dsPIC33, indicati
if(nr==2){ codul C pentru a ilustra de cate ori a avul loc comutarea catre idle.
flag=1; // semafor ocupat Se vor folosi facilitati trace/hook.
nr=0;}} #define configUSE_TRACE_FACILITY 1 #define
void myReceive(hS){ configUSE_TICK_HOOK 1
flag=0; //semafor eliberat} #define traceTASK_SWITCH_IN() mySwitch_IN()
#define traceTASK_SWITCH_OUT() mySwitch_OUT()
13. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
unsigned int var = 0;
indicati codul C pentru a ilustra, la momentul curent (masurat fata
char firstSwitchIN, switchOutidle;
de inceputul executiei aplicatiei), in cate cadre coada de mesaje (cu
void vApplicationTickHook(void){
handlerul Q) a avut un singur mesaj pe toata durata cadrului (pe
if(xTaskGetIdleTaskHandle() == xTaskGetCurrentHandle())
durata cadrului, Q nu a avut mai mult sau mai putin de 1 un mesaj).
var++;
Se presupune ca aceasta coada are o adancime mai mare ca 1. Se
firstSwtichIN=1;}
vor folosi facilitati trace/hook. xQueueHandle Q;
#define traceQUEUE_RECEIVE(pxQueue) f_receive(pxQueue);
17. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
#define traceQUEUE_SEND(pxQueue) f_send(pxQueue);
indicati codul C pentru a ilustra de cate ori taskul B (cu handler
unsigned int flagS=0, flagR=0;
hB) a eliberat un semafor binar cu handlerul hS. Se vor folosi
void f_send(pxQueue) {
facilitati trace/hook.
if(pxQueue==Q)
SemaphoreHandle hs = NULL;
flagS=1;
SemaphoreHandle hb = NULL;
}
int main(void) {
void f_receive(pxQueue) {
hs=xSemaphoreCreateBinary(); void _sendFailed (pxQueue) {
portTickType t = xTaskGetTickCount(); if (pxQueue==q2)
int a; flag--;}
for(){
if(SemaphoreTake (hs, portMAX_DELAY){ //de cate ori s-a efectuat corect scrierea in Q2, dar cu intrare in
vPartTestToggle(15): blocare a taskului care scrie (pentru asteptarea ccesului la coada)
vTaskDelay(5) QueueHandle q2:
xSemaphoreGive(hs) unsigned nr=0;
a++; int flag = 0;
TaskDelayUntil(&t.10):} #define traceQUEUE_SEND (pxQueue) f_send (pxQueue)
vTaskDelayUntil(&t10)} #define traceBLOCKING_ON_QUEUE_SEND (pxQueue) f
vTaskStartScheduler(); blockingSend (pxQueue)
return 0:} #define traceQUEUE_SEND_FAILED (pxQueue) f_sendFailed
(pxQueue)
CURS
1. void f_send (pxQueue){
if(flag > 0 && pxQueue == q2) {
xQueueHandle Queue1H, Queue2H: nr=nr+1;}
xTaskHandle hT10, hT20, hT3 flag=flag-1;}

void T1 (void * pvparameters) { void f_blockingSend (pxQueue){

portTickType t = xTaskGetTickCount(); if (pxQueue ==q2)
int a, b, c, cod: flag=flag+1;
for (;;){
vTaskSuspendAll(); void f_sendFailed (pxQueue) {
a = RB15; if (pxQueue==q2)
b = RB14; flag=flag-1;
c = _RB13;
cod = a*4 + b*2+ cr
vTaskResumeAll();
xQueueSend (QueuelH, &cod, 0);
vTaskDelayUntil(&t, 5);}}

void main (void){

Queue1H=xQueueCreate (2, sizeof(int));
Queue2H = xQueueCreate (3, sizeof(int)); xTaskCreate
(T1,...,&hT1);
xTaskCreate (T2,...., ahT2): xTaskCreate (T3,...,shT3);
vStartScheduler();}

2.//de cate ori accesul la citire din Q2 s-a efectuat corect

xQueueHandle q2:
unsigned nr 0:
#define traceQUEUE_RECEIVE (pxQueue) f receive (pxQueue)
void f receive (pxQueue){
if (pxQueue=q2)
nr=nr++ :

//de cate ori accesul la scriere in Q2 5-a efectuat correct, fara

intrare in blocare

QueueHandle q2;
unsigned nr=0;
#define traceQUEUE_SEND (pxQueue) f_send (pxQueue)
#define traceBLOCKING_ON_QUEUE_SEND (pxQueue)
f_blockingSend (pxQueue)

void f_send (pxQueue){

if(flag==0 && pxQueue == 12) {
nr++;
flag--}

void f_blockingSend (pxQuee){

if (pxQueue==q1){
flag++;}}