Résumé FREE RTOS

Rappel
#define bouton_urgence GPIO_PIN_0 ;
#define bouton_marche GPIO_PIN_1 ; Definition des variable
#define bouton_montee GPIO_PIN_2 ;
Exemple 1 :créer deux taches
osThreadId blueHandle , redHandle;
void SystemClock_Config(void); Création du Handle des taches
static void MX_GPIO_Init(void);
void VLEDBLUE(void const * argument); Déclaration des fonctions des taches
void VLEDRED(void const * argument);
-----------------------------------------------------------------
xTaskCreate( VLEDBLUE, "LED BLUE",128,NULL,1,blueHandle); Création des taches dans le main
xTaskCreate( VLEDRED, "LED RED",128,NULL,1,redHandle);
-----------------------------------------------------------------
void VLEDBLUE(void const * argument)
{ for(;;)
{ HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_15);
HAL_Delay(500); }} Corps des fonctions
-----------------------------------------------------------------
void VLEDRED(void const * argument)
{ for(;;)
{ HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_14);
HAL_Delay(250); }}
Exemple 2 :Deux taches utilisent la même fonction
typedef struct Tache nécessite plusieurs variables ==> structure
{ uint16_t pin; Définition de la structure
TickType_t tick;
} toggle ;
toggle Blue, Red;
void ftoggle(void const * argument); Déclaration de la fonction des taches
-----------------------------------------------------------------
Blue.pin=GPIO_PIN_14;
Blue.tick=500; Dans le main
Red.pin=GPIO_PIN_15;
Red.tick=300;
xTaskCreate( ftoggle, "LED BLUE",128,&Blue,1,blueHandle);
xTaskCreate( ftoggle, "LED RED",128,&Red,1,redHandle); Création des taches
-----------------------------------------------------------------
void ftoggle(void const * argument)
{ toggle led; Corps de la fonction
led=*(toggle*)argument;
for(;;)
{HAL_GPIO_TogglePin(GPIOD, led.pin); Bloque la tache pendant 500ms :
vTaskDelay(led.tick/portTICK_PERIOD_MS); } vTaskDelay( 500 / portTICK_PERIOD_MS);

Exemple 3 : Communication entre deux taches

osThreadId lireHandle , ecrireHandle; Création du Handle des taches
xQueueHandle queue; Création du Handle de la queue
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
void lireB(void const * argument); Déclaration des fonctions des taches
void ecrireL (void const * argument);
----------------------------------------------------------------- Main
queue =xQueueCreate( 1,sizeof (char)); //char ou bien Création de la queue
xTaskCreate( (void*)lireB, "lire",128,NULL,1,lireHandle); Création des taches
xTaskCreate((void*) ecrireL, "ecrire",128,NULL,1,ecrireHandle);
----------------------------------------------------------------- Corps des fonctions

1
void lireB(void const * argument)
{ unsigned char A;
for(;;)
{ A=HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0);
xQueueSendToBack(queue,&A,0); } } Ecrire une valeur dans la queue
-----------------------------------------------------------------
void ecrireL(void const * argument)
{ unsigned char B;
for(;;)
{ xQueueReceive(queue,&B,0); Lire une valeur de la queue
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12,B); } }
Exemple 4 : Compteur : Mutex & Semaphore
osThreadId TA1,TA2,vTcount; Création du Handle des taches
xSemaphoreHandle mutex; Création du Handle du mutex (Jeton)
xQueueHandle unite , dizaine; Création du Handle des queues
void t1_tache(void const * argument);
void t2_tache(void const * argument); Déclaration des fonctions des taches
void Tcount_tache (void const * argument);
unsigned char Dec2Bcd (unsigned short DEC);
----------------------------------------------------------------- Main
xTaskCreate(t1_tache,"tache1",128,NULL,1,TA1); Création des taches
xTaskCreate(t2_tache,"tache2",128,NULL,1,TA2);
xTaskCreate(Tcount_tache,"tache_count",128,NULL,1,vTcount);
mutex= xSemaphoreCreateMutex(); Création du Mutex
unite =xQueueCreate(1,sizeof(unsigned short)); Création des queues
dizaine =xQueueCreate(1,sizeof(unsigned short));
osKernelStart(); osKernelStart annance le depart des taches.
-----------------------------------------------------------------
unsigned char Dec2Bcd (unsigned short DEC) Corps des fonctions
{uint16_t BCD[10]={0x03,0x9f,0x25,0x0d,0x99,0x49,0x41,0x1f,0x01,0x09};
return BCD[DEC]; }

void t1_tache(void const * argument)

{unsigned short D;
for(;;) Lire une valeur de la queue dizaine
{ xQueueReceive(dizaine,&D,0); Prendre le jeton du mutex
xSemaphoreTake(mutex,portMAX_DELAY);
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,1);
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,0);
GPIOA->ODR= Dec2Bcd(D);
xSemaphoreGive(mutex); Rendre le jeton
osDelay(2); } } Attendre 2ms
void t2_tache(void const * argument)
{unsigned short U;
for(;;)
{ xQueueReceive(unite,&U,0);
xSemaphoreTake(mutex,portMAX_DELAY); Lire une valeur de la queue unite
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,1); Prendre le jeton du mutex
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,0);
GPIOA->ODR= Dec2Bcd(U);
xSemaphoreGive(mutex);
osDelay(2); } } Rendre le jeton
Attendre 2ms
void Tcount_tache (void const * argument)
{ unsigned short U,D;
for(;;)
{for(D=0;D<10;D++)
{for(U=0;U<10;U++)
{ xQueueSendToBack(unite,&U,portMAX_DELAY); Ecrire des valeurs dans les queues
xQueueSendToBack(dizaine,&D,portMAX_DELAY);
osDelay(1000); }}}} Attendre 1s

2
Exemple 5 : Deux leds : Interruption taches
TaskHandle_t ledh,irqh; Dans le main.c
xSemaphoreHandle binary_mutex=NULL; Création du Handle du mutex
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
void led(void const * argument); Déclaration des fonctions des taches
void irq(void const * argument);
static void MX_NVIC_Init(void);
----------------------------------------------------------------- Main
binary_mutex=xSemaphoreCreateBinary(); Création du Mutex
xTaskCreate(led,"led1",128,NULL,1,ledh); Création des taches
xTaskCreate(irq,"lediqr",128,NULL,1,irqh);
----------------------------------------------------------------- Les fonctions
void led(void const * argument)
{ for(;;)
{ HAL_GPIO_TogglePin( GPIOD, GPIO_PIN_12); Fonction de la tâche principale
HAL_Delay(1000); } }

void irq(void const * argument)

{ for(;;) Fonction de la tache commander par l’interruption
{ xSemaphoreTake(binary_mutex,portMAX_DELAY); Prendre le jeton
HAL_GPIO_TogglePin( GPIOD, GPIO_PIN_13); } }
---------------------------------------------------------------------------- Dans le stm32f4xx_it.c
extern xSemaphoreHandle binary_mutex; Variable extern, defini dans le main.c
------------------------------------
void EXTI0_IRQHandler(void) Fonction de l’interruption
{ BaseType_t *pxHigherPriorityTaskWoken;
xSemaphoreGiveFromISR(binary_mutex,pxHigherPriorityTaskWoken); Donner le jeton
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0); }
Exemple 6 : pause sur les taches
osThreadId LEDThread1Handle, LEDThread2Handle; Création du Handle des taches
xSemaphoreHandle mutex; Création du Handle du mutex
-----------------------------------------------------------------
osThreadDef(TH1_name, LED_Thread1, osPriorityNormal + 1, 0, Main
configMINIMAL_STACK_SIZE); Définir les taches
osThreadDef(TH2_name, LED_Thread2, osPriorityNormal, 0,
configMINIMAL_STACK_SIZE);
LEDThread1Handle = osThreadCreate (osThread(TH1_name), NULL); Création des taches
LEDThread2Handle = osThreadCreate (osThread(TH2_name), NULL);
mutex= xSemaphoreCreateMutex(); Création du Mutex
osKernelStart(); osKernelStart annance le depart des taches.
-----------------------------------------------------------------
static void LED_Thread1(void const *argument) Corps des fonctions
{uint32_t count = 0;
(void) argument;
for(;;)
{ xSemaphoreTake(mutex,portMAX_DELAY); Prendre le jeton du mutex
count = osKernelSysTick() + 5000; osKernelSysTick() : temporisateur, il se
while (count >= osKernelSysTick()) déclenche a l’exécution de osKernelStart
{ BSP_LED_Toggle(LED5);
osDelay(200); } Attendre 200ms
BSP_LED_Off(LED5);
xSemaphoreGive(mutex); Rendre le jeton
osThreadResume(LEDThread2Handle); Réactiver la tache 2
osThreadSuspend(NULL); } } Suspendre la tache 1

static void LED_Thread2(void const *argument)

{ uint32_t count;
(void) argument;
for(;;)

3
{ xSemaphoreTake(mutex,portMAX_DELAY); Prendre le jeton du mutex
count = osKernelSysTick() + 10000;
while (count >= osKernelSysTick())
{ BSP_LED_Toggle(LED6); Attendre 500ms
osDelay(500); }
BSP_LED_Off(LED6);
xSemaphoreGive(mutex); Rendre le jeton
osThreadResume(LEDThread1Handle); Reactiver la tache 1
osThreadSuspend(NULL); }} Suspendre la tache 2