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.
traceTASK_CREATE(pxTask) - Apelata din xTaskCreate daca if( xSemaphoreTake( xSemaphore, ( portTickType ) 10 ) ==
taskul este creat cu succes. pdTRUE ){
traceTASK_CREATE_FAILED() - Apelata din xTaskCreate xSemaphoreGive( xSemaphore );}
dacă taskul nu este creat cu success, din cauză ca nu exista take e receive, give e send
traceCREATE_COUNTING_SEMAPHORE(pxSem),
memorie heap suficientă traceCREATE_COUNTING_SEMAPHORE_FAILED()
traceTASK_DELETE(pxTask) - Apelata din vTaskDelete. traceCREATE_MUTEX(pxMutex), traceCREATE_MUTEX_FAILED()
traceTASK_DELAY_UNTIL() - Apelata din vTaskDelayUntil. traceGIVE_MUTEX_RECURSIVE(pxMutex),
traceGIVE_MUTEX_RECURSIVE_FAILED(pxMutex) (alt propritar solicita acces
traceTASK_DELAY() - Apelata din vTaskDelay. recursiv) traceTAKE_MUTEX_RECURSIVE(pxMutex)+trace de la cozi
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{
flag1=0:
#define traceTASK_INCREMENT_TICK(xTickCount( void
flag2=0;}
traceincrement(xTickCount)));
}
xTaskHandle hB; //handle pentru task-ul B
unsigned char numarintreruperi = 0, flagTaskB = 0; //folosim flag-
2. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
ul sa verif. daca task-ul B preda procesorul
indicati codul C pentru a ilustra de cate ori a fost solicitata tranzitia
taskului B (cu handler hB) din starea „Suspended", solicitarea find void taskSwitchedOut(){
facuta dintr-un task mai putin prioritar decat B. Se vor folosi if(pxCurrentTCB = hB){
facilitati trace/hook. flagTaskB = 1;}
}
#define traceTASK SUSPEND(XTask) TaskSuspended(xTask);
#define traceTASK RESUM(xTask) TaskResume(xTask); void traceincrement(xTickCount){
#define traceTASK INCREMENT TICK(XTickCount) if(flagTaskB==1){
increment(xTickCount); numarintreruperi++;} //daca task-ul B a cedat procesorul si
xTaskHandle hB=NULL; imediat avem ISR t Real atunci avem conditia:
xTaskHandle hA=NULL; else
char flag=0; flagTaskB = 0; }
portTickType numarCadre=0;
5. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
void TaskSuspended(xTask){
indicate codul C pentru a ilustra, la momentul current t (masurat
if(xTask-=hT1 && uxTaskPriorityGet(hT1)>uxTask
fata de inceputul executiei aplicatiei), in cate cadre coada de
PriorityGet(hT2)){
mesaje (cu handler Q) a avut un singur mesaj pe toata durata
flag=1;}
cadrului (pe durata cadrului, Q nu a avut mai mult sau mai putin de
1 mesaj). Se presupune ca aceasta coada are o adancime mai mare
void TaskResume(xTask){
ca 1. Se vor folosi facilitate trace/hook.
#define traceQUEUE_SEND(XQueue) void In main.c:
traceQueueSend(xQueue): extern tskTCB * volatile pxCurrentTCB;
#define traceQUEUE_RECIEVE(xQueue) void usigned int switch_A=0;
traceQueueRecieve(xQueue): usigned int switch_B=0;
#define traceTASK_INCREMENT_TICK(xQueue) void char mess;
traceIncr(xQueue); xQueueHandle hQ:
unsigned char numarMesajeQ = 0 void vBlocking(HS) {
portTickType cadru= 0, t, momentCacruR, momentCadrus: if(hA== pxCurrentTCB)
switch A++;
void traceQueueSend(xQueue){ if(hB == pxCurrentTCB)
if(hQ== xQueue){numarMesajeQ++;) switch B++;
momentCadruS = xTaskGetTickCount(); if(switch_A>switch B)
} mess='A';
else
void traceQueueRecieve(xQueue){ mess='B';}
if(hQ== xQueue){ numarMesajeQ--:)
momentCadruR == xTaskGetTickCount(): 8. Se considera o aplicatie dezvoltata pentru FreeRTOS si
} dsPIC33. Taskul T1 (creat in main) trebuie sa asigure urmatoarele
functionalitati: citeste un mesaj din coada Q, asteptand maxim 200
void traceincr(xQueue){
msec acces la coada. Daca citirea din coada nu a putut fi efectuata
if(numarMesajeQ== 1 && momentCadrus == momentCadruR)
cu succes, T1 scrie 0 pe PORTB10 si mentine aceasta valoare
{ t++;} // daca in momente egale avem un mesaj, in coada avem
constanta pentru un numar de milisecunde egal cu numarul de citiri
conditia
esuate ale lui T1, din Q. Apoi T1 intra in blocare pentru 200 msec.
cadru++;
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.

void T1(void *params){

7. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
unsigned portBASE_TYPE N=uxTaskGetNumberOfTasks();
indicati codul C pentru a ilustra, pana la momentul curent t static int accesari=0;
(masurat de la inceputul executiei aplicatiei), care dintre taskurile for(;;){
A (cu handler hA) si B (cu handler hB) a asteptat mai multe cadre if(xSemaphoreTake(hs,0)==pdTrue){
accesul la semaforul binar S (cu handler hS). Cele doua taskuri au _RB10=0;
timeout infinit pentru accesul la semaforul S. Se vor folosi facilitati accesari++;
trace/hook. xQueueSend(Q,0,portMAX_DELAY);
In FreeRTOSConfig.h: vTaskDelay(N*1);
#define configUSE_TRACE FACILITY xSemaphore Give(hS);}
#define traceBLOCKING ON QUEUE RECEIVE(pxQueue) else{
vBlocking(hS) xQueueSend(Q,&accesari portMAX_DELAY);}
//#define INCLUDE_xTaskGetCurrentTaskHandle 1
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( ; ; ) {
#define traceBLOCKING ON QUEUE RECEIVE(hS) myblocking if(xSemaphoreTake(sem,1)==pdTRUE) {
(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,
indicati codul C pentru a ilustra, la momentul curent (masurat fata unsigned int var = 0;
de inceputul executiei aplicatiei), in cate cadre coada de mesaje (cu char firstSwitchIN, switchOutidle;
handlerul Q) a avut un singur mesaj pe toata durata cadrului (pe void vApplicationTickHook(void){
durata cadrului, Q nu a avut mai mult sau mai putin de 1 un mesaj). if(xTaskGetIdleTaskHandle() == xTaskGetCurrentHandle())
Se presupune ca aceasta coada are o adancime mai mare ca 1. Se var++;
vor folosi facilitati trace/hook. xQueueHandle Q; firstSwtichIN=1;}
#define traceQUEUE_RECEIVE(pxQueue) f_receive(pxQueue);
#define traceQUEUE_SEND(pxQueue) f_send(pxQueue); 17. Pentru o aplicatie dezvoltata pentru FreeRTOS si dsPIC33,
unsigned int flagS=0, flagR=0; indicati codul C pentru a ilustra de cate ori taskul B (cu handler
void f_send(pxQueue) { hB) a eliberat un semafor binar cu handlerul hS. Se vor folosi
if(pxQueue==Q) facilitati trace/hook.
flagS=1; SemaphoreHandle hs = NULL;
} SemaphoreHandle hb = NULL;
void f_receive(pxQueue) { int main(void) {
if(pxQueue==Q)
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++;}}