#include "stm32c0xx_hal.h"
#include "FreeRTOS.h"  
#include "task.h"  

#define tledR_PERIO_P 1000 // Période de la tâche 1 en ms
#define tledR_CAPACITY 200 // Capacité de la tâche 1 en ms

#define tledB_PERIO_P 4000 // Période de la tâche 2 en ms
#define tledB_CAPACITY 300 // Capacité de la tâche 2 en ms

#define tledV_PERIO_P 2000 // Période de la tâche 3 en ms
#define tledV_CAPACITY 500 // Capacité de la tâche 3 en ms

uint16_t pa0 = GPIO_PIN_0;
uint16_t pa1 = GPIO_PIN_1;
uint16_t pa4 = GPIO_PIN_4;

/* Prototypes de fonctions */
void SystemClock_Config(void);
static void MX_GPIO_Init(void);

void tled(void* p);  
 
void MX_GPIO_Init(void)  
{  
/* GPIO Ports Clock Enable */  
  __HAL_RCC_GPIOA_CLK_ENABLE();

GPIO_InitTypeDef GPIO_InitStruct = {0};  

/*Configure GPIO pins: PAO, PA1 PA4*/  
GPIO_InitStruct. Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_4;  
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;  
GPIO_InitStruct. Pull = GPIO_NOPULL;  
GPIO_InitStruct. Speed = GPIO_SPEED_FREQ_LOW;  
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);  

}  

int main(void)
{
/* Initialisation de HAL */
  HAL_Init();
/* Configuration de l'horloge système */
  SystemClock_Config();
/* Initialisation des périphériques */
  MX_GPIO_Init();
/* Vérification de la capacité des tâches */
  if (((tledR_CAPACITY / (float)tledR_PERIO_P))+((tledB_CAPACITY / (float)tledB_PERIO_P))+((tledV_CAPACITY / (float)tledV_PERIO_P))  <= 1.0)
    {
/* Création des tâches */
       xTaskCreate(tled, "tledPA0", 128, &pa0, 1, NULL);
       xTaskCreate(tled, "tledPA1", 128, &pa1, 1, NULL);
       xTaskCreate(tled, "tledPA4", 128, &pa4, 1, NULL);
/* Démarrage du système d'exploitation temps réel */
    vTaskStartScheduler();
    }
    else
    { 
    printf("condition nécessaire non verifié\n"); //error
    }
/* Boucle infinie */
  while (1) 
  {
  }
}
void tled(void* p)
{
   // Récupération de la broche à partir du pointeur passé en paramètre
// p est un pointeur vers void qui contient l'adresse de pa0.
// Nous le convertissons en pointeur vers uint16_t pour accéder à la valeur de la broche.
// En utilisant l'opérateur de déférencement *, nous assignons la valeur de pa0 à la variable 'broche'.
    uint16_t broche = *((uint16_t*)p);
    uint32_t capacity = 0;
    uint32_t period = 0;

    if (broche == pa0) 
    { printf("led v");
      capacity = tledV_CAPACITY;
      period = tledV_PERIO_P; 
    }
    else if (broche == pa1) 
    { printf("led r");
      capacity = tledR_CAPACITY; 
      period = tledR_PERIO_P; 
    }
    else if (broche == pa4) 
    { printf("led b");
      capacity = tledB_CAPACITY; 
      period = tledB_PERIO_P; 
    }
    while (1)
  {
        HAL_GPIO_WritePin(GPIOA, broche, GPIO_PIN_SET);   // LED ON
        vTaskDelay(capacity / portTICK_PERIOD_MS);  // Pause pour allumer la LED
        HAL_GPIO_WritePin(GPIOA, broche, GPIO_PIN_RESET); // LED OFF
        vTaskDelay((period - capacity) / portTICK_PERIOD_MS); // Attendre le reste de la période
    }
}
 /*  TickType_t xLastWakeTime = xTaskGetTickCount();

   while (1)
    {
        HAL_GPIO_WritePin(GPIOA, broche, GPIO_PIN_SET);
        vTaskDelay(pdMS_TO_TICKS(capacity));
        HAL_GPIO_WritePin(GPIOA, broche, GPIO_PIN_RESET);

        // Délai jusqu’à la période suivante
        vTaskDelayUntil(&xLastWakeTime, pdMS_TO_TICKS(period));
    }
}*/
void vApplicationIdleHook(void)
{
  // Fonction de ralentissement de FreeRTOS
}