257 lines
8.5 KiB
C
257 lines
8.5 KiB
C
#include <stdio.h>
|
||
#include <string.h>
|
||
#include "eventsManager.h"
|
||
#include "esp_log.h"
|
||
#include "mqtt_client.h"
|
||
#include "obtain_time.h"
|
||
#include <time.h>
|
||
#include "meteofrance.h"
|
||
#if CONFIG_IDF_TARGET_ESP32P4
|
||
#include "audio.h"
|
||
#endif
|
||
|
||
EventGroupHandle_t domotic_event_group;
|
||
QueueHandle_t ihm_queue;
|
||
extern esp_mqtt_client_handle_t client;
|
||
|
||
static const char *TAG = "evtMgr";
|
||
|
||
void startEvtManager(){
|
||
domotic_event_group = xEventGroupCreate();
|
||
ihm_queue = getIHMQueueHandle();
|
||
|
||
/* Tache updateTime */
|
||
BaseType_t ret2 = xTaskCreate(&updateTime, "updateTimeTask", 3 * 1024, NULL, 5, NULL);
|
||
if (ret2 != pdPASS)
|
||
{
|
||
ESP_LOGE(TAG, "Impossiblke de creer la tache updateTimeTask %i", ret2);
|
||
}
|
||
/* Tache updateTime - FIN*/
|
||
}
|
||
|
||
const char * domo_event_to_str(domo_events evt)
|
||
{
|
||
switch (evt) {
|
||
case EVT_WIFI_CONNECTED: return "WIFI_CONNECTED";
|
||
case EVT_TIME_SETTED: return "TIME_SETTED";
|
||
case EVT_BTN_VOLET: return "BTN_VOLET";
|
||
case EVT_PUISSANCE_RECUE: return "PUISSANCE_RECUE";
|
||
case EVT_ETAT_MACHINE: return "ETAT_MACHINE";
|
||
case EVT_HAUTEUR_CUVE: return "HAUTEUR_CUVE";
|
||
case EVT_METEO_RECUE: return "METEO_RECUE";
|
||
case EVT_TEMP_EXT: return "TEMP_EXT";
|
||
case EVT_TEMP_INT: return "TEMP_INT";
|
||
case EVT_FIN_MACHINE: return "FIN_MACHINE";
|
||
case EVT_FIN_MACHINE_STOP_NOTIF: return "FIN_MACHINE_STOP_NOTIF";
|
||
default: return "EVT_UNKNOWN";
|
||
}
|
||
}
|
||
|
||
const char * ihm_event_to_str(eIHMEvent_t evt)
|
||
{
|
||
switch (evt) {
|
||
case IHM_EVT_WIFI_STATUS: return "IHM_WIFI_STATUS";
|
||
case IHM_EVT_TIME_SETTED: return "IHM_TIME_SETTED";
|
||
case IHM_EVT_OTA_STARTED: return "IHM_OTA_STARTED";
|
||
case IHM_EVT_OTA_PROGRESS: return "IHM_OTA_PROGRESS";
|
||
case IHM_EVT_HUMID_TEMP: return "IHM_HUMID_TEMP";
|
||
case IHM_EVT_PUISSANCE_EMISE: return "IHM_PUISSANCE_EMISE";
|
||
case IHM_EVT_ETAT_MACHINE: return "IHM_ETAT_MACHINE";
|
||
case IHM_EVT_HAUTEUR_CUVE: return "IHM_HAUTEUR_CUVE";
|
||
case IHM_EVT_METEO_RECUE: return "IHM_METEO_RECUE";
|
||
case IHM_EVT_TEMP_RECUE: return "IHM_TEMP_RECUE";
|
||
default: return "IHM_EVT_UNKNOWN";
|
||
}
|
||
}
|
||
|
||
void send_event(domo_events evt, void* pDatas) {
|
||
ESP_LOGI(TAG, "EventManager: On est dans l'event handler %s", domo_event_to_str(evt));
|
||
|
||
xIHMEvent_t *ihmEvt = malloc(sizeof(xIHMEvent_t));
|
||
if (!ihmEvt) {
|
||
ESP_LOGE(TAG, "malloc failed for event struct");
|
||
return;
|
||
}
|
||
|
||
switch (evt) {
|
||
case EVT_WIFI_CONNECTED: {
|
||
xEventGroupSetBits(domotic_event_group, WIFI_CONNECTED_BIT);
|
||
ESP_LOGI(TAG, "connected to AP SSID");
|
||
|
||
bool *wifiStatus = malloc(sizeof(bool));
|
||
if (!wifiStatus) {
|
||
ESP_LOGE(TAG, "malloc failed for wifiStatus");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
*wifiStatus = true;
|
||
|
||
ihmEvt->eEventType = IHM_EVT_WIFI_STATUS;
|
||
ihmEvt->pvData = wifiStatus;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
}
|
||
|
||
case EVT_TIME_SETTED:
|
||
struct tm *msg = (struct tm *)pDatas;
|
||
struct tm *msg_copy = malloc(sizeof(struct tm));
|
||
if (!msg_copy)
|
||
{
|
||
ESP_LOGE(TAG, "malloc failed for message string");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
// Vérifier que msg n'est pas NULL avant de copier
|
||
if (msg == NULL)
|
||
{
|
||
fprintf(stderr, "msg est NULL !\n");
|
||
free(msg_copy);
|
||
return;
|
||
}
|
||
|
||
|
||
*msg_copy = *msg;
|
||
ihmEvt->eEventType = IHM_EVT_TIME_SETTED;
|
||
ihmEvt->pvData = msg_copy;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
|
||
case EVT_BTN_VOLET:
|
||
esp_mqtt_client_publish(client, "volets", pDatas, 0, 0, 0);
|
||
free(ihmEvt); // rien à envoyer à l'IHM
|
||
ihmEvt = NULL;
|
||
return;
|
||
|
||
case EVT_PUISSANCE_RECUE:
|
||
ESP_LOGI(TAG, "Puissance recue %i", *(int*)pDatas);
|
||
int *data = malloc(sizeof(int));
|
||
if (!data) {
|
||
ESP_LOGE(TAG, "malloc failed for puissance_5mn");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
*data = *(int *)pDatas;
|
||
ihmEvt->eEventType = IHM_EVT_PUISSANCE_EMISE;
|
||
ihmEvt->pvData = data;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
|
||
case EVT_ETAT_MACHINE:
|
||
const char *msg2 = (const char *)pDatas;
|
||
char *msg_copy2 = malloc(strlen(msg2) + 1);
|
||
if (!msg_copy2) {
|
||
ESP_LOGE(TAG, "malloc failed for message string");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
strcpy(msg_copy2, msg2);
|
||
ihmEvt->eEventType = IHM_EVT_ETAT_MACHINE;
|
||
ihmEvt->pvData = msg_copy2;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
|
||
case EVT_TEMP_EXT:
|
||
const char *msg3 = (const char *)pDatas;
|
||
char *msg_copy3 = malloc(strlen(msg3) + 1);
|
||
if (!msg_copy3) {
|
||
ESP_LOGE(TAG, "malloc failed for message string");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
strcpy(msg_copy3, msg3);
|
||
ihmEvt->eEventType = IHM_EVT_TEMP_RECUE;
|
||
ihmEvt->pvData = msg_copy3;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
|
||
case EVT_TEMP_INT:
|
||
const char *msg4 = (const char *)pDatas;
|
||
char *msg_copy4 = malloc(strlen(msg4) + 1);
|
||
if (!msg_copy4) {
|
||
ESP_LOGE(TAG, "malloc failed for message string");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
strcpy(msg_copy4, msg4);
|
||
ihmEvt->eEventType = IHM_EVT_HUMID_TEMP;
|
||
ihmEvt->pvData = msg_copy4;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
|
||
//On envoie les données via mqtt
|
||
esp_mqtt_client_publish(client, topicTempInt, pDatas, 0, 0, 0);
|
||
|
||
break;
|
||
|
||
case EVT_HAUTEUR_CUVE: {
|
||
float *data = malloc(sizeof(float));
|
||
if (!data) {
|
||
ESP_LOGE(TAG, "malloc failed for hauteur_cuve");
|
||
free(ihmEvt);
|
||
return;
|
||
}
|
||
*data = *(float *)pDatas;
|
||
ESP_LOGE(TAG, "EVENT_HANDLER -> On a recu %f", *data);
|
||
ihmEvt->eEventType = IHM_EVT_HAUTEUR_CUVE;
|
||
ihmEvt->pvData = data;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
}
|
||
|
||
case EVT_METEO_RECUE:{
|
||
meteo_event_payload_t *incoming = (meteo_event_payload_t *) pDatas;
|
||
meteo_event_payload_t *payload = malloc(sizeof(meteo_event_payload_t));
|
||
if (payload == NULL) {
|
||
// gérer l’erreur
|
||
return;
|
||
}
|
||
|
||
memcpy(payload->daily, incoming->daily, sizeof(incoming->daily));
|
||
memcpy(payload->forecast, incoming->forecast, sizeof(incoming->forecast));
|
||
ihmEvt->eEventType = IHM_EVT_METEO_RECUE;
|
||
ihmEvt->pvData = payload;
|
||
ihmEvt->bNeedToFreeData = true;
|
||
break;
|
||
}
|
||
|
||
case EVT_FIN_MACHINE:{
|
||
#if CONFIG_IDF_TARGET_ESP32P4
|
||
playSound();
|
||
#endif
|
||
ihmEvt->eEventType = IHM_EVT_MACHINE_TERMINEE;
|
||
ihmEvt->pvData = NULL;
|
||
ihmEvt->bNeedToFreeData = false;
|
||
break;
|
||
}
|
||
|
||
case EVT_FIN_MACHINE_STOP_NOTIF:{
|
||
#if CONFIG_IDF_TARGET_ESP32P4
|
||
stopSound();
|
||
#endif
|
||
free(ihmEvt); // rien à envoyer à l'IHM
|
||
ihmEvt = NULL;
|
||
break;
|
||
}
|
||
|
||
default:
|
||
ESP_LOGE(TAG, "Unhandled event type");
|
||
free(ihmEvt);
|
||
ihmEvt = NULL;
|
||
return;
|
||
}
|
||
if( ihm_queue != NULL && ihmEvt){
|
||
ESP_LOGI(TAG, "Suite %s : Envoi d'un evt %s (%i) a l'IHM", domo_event_to_str(evt), ihm_event_to_str(ihmEvt->eEventType),ihmEvt->eEventType);
|
||
if (xQueueSendToFront(ihm_queue, &ihmEvt, pdMS_TO_TICKS(10)) != pdPASS)
|
||
{
|
||
ESP_LOGE(TAG, "La queue est pleine");
|
||
if (ihmEvt->bNeedToFreeData && ihmEvt->pvData)
|
||
{
|
||
free(ihmEvt->pvData);
|
||
}
|
||
free(ihmEvt);
|
||
}
|
||
}else{
|
||
ESP_LOGI(TAG, "Suite %s : on n'envoie rien a l'IHM", domo_event_to_str(evt));
|
||
|
||
}
|
||
}
|