new buzzer component

components/buzzer/CMakeLists.txt

@@ -0,0 +1,12 @@
+set(srcs 
+    "src/buzzer.c"
+    "src/buzzer_events.c"
+)
+
+idf_component_register(
+    SRCS ${srcs}
+    INCLUDE_DIRS "include"
+    PRIV_INCLUDE_DIRS "src"
+    REQUIRES esp_event
+    PRIV_REQUIRES driver nvs_flash esp_timer evse
+)

components/buzzer/idf_component.yml

@@ -0,0 +1,2 @@
+version: "2.6.0"
+description: Authentication component

components/buzzer/include/buzzer.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void buzzer_init(void);
+
+#ifdef __cplusplus
+}
+#endif

components/buzzer/include/buzzer_events.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "esp_event.h"
+
+ESP_EVENT_DECLARE_BASE(BUZZER_EVENTS);
+
+typedef enum {
+    BUZZER_EVENT_PLAY_PATTERN,
+} buzzer_event_id_t;
+
+typedef enum {
+    BUZZER_PATTERN_NONE = 0,
+    BUZZER_PATTERN_PLUGGED,
+    BUZZER_PATTERN_UNPLUGGED,
+    BUZZER_PATTERN_CHARGING,
+    BUZZER_PATTERN_AP_START,
+    BUZZER_PATTERN_CARD_READ,
+    BUZZER_PATTERN_CARD_ADD,
+    BUZZER_PATTERN_CARD_DENIED,
+    BUZZER_PATTERN_MAX
+} buzzer_pattern_id_t;
+
+
+typedef struct {
+    buzzer_pattern_id_t pattern;
+} buzzer_event_data_t;

components/buzzer/src/buzzer.c

@@ -0,0 +1,168 @@
+#include "buzzer_events.h"
+#include "evse_events.h"
+#include "auth_events.h"
+#include "network_events.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/gpio.h"
+
+#define BUZZER_GPIO GPIO_NUM_27
+static const char *TAG = "Buzzer";
+
+typedef struct {
+    uint16_t on_ms;
+    uint16_t off_ms;
+} buzzer_step_t;
+
+// Padrões de buzzer
+static const buzzer_step_t pattern_plugged[]     = {{100, 100}, {200, 0}};
+static const buzzer_step_t pattern_unplugged[]   = {{150, 150}, {150, 150}, {150, 0}};
+static const buzzer_step_t pattern_charging[]    = {{80, 150}, {100, 120}, {120, 100}, {140, 0}};
+static const buzzer_step_t pattern_ap_start[]    = {{300, 150}, {300, 0}};
+static const buzzer_step_t pattern_card_read[]   = {{50, 50}, {50, 0}};
+static const buzzer_step_t pattern_card_add[]    = {{100, 100}, {100, 100}, {100, 0}};
+static const buzzer_step_t pattern_card_denied[] = {{300, 100}, {300, 0}};
+
+typedef struct {
+    const buzzer_step_t *steps;
+    size_t length;
+} buzzer_pattern_t;
+
+static const buzzer_pattern_t buzzer_patterns[] = {
+    [BUZZER_PATTERN_PLUGGED]     = {pattern_plugged,     sizeof(pattern_plugged) / sizeof(buzzer_step_t)},
+    [BUZZER_PATTERN_UNPLUGGED]   = {pattern_unplugged,   sizeof(pattern_unplugged) / sizeof(buzzer_step_t)},
+    [BUZZER_PATTERN_CHARGING]    = {pattern_charging,    sizeof(pattern_charging) / sizeof(buzzer_step_t)},
+    [BUZZER_PATTERN_AP_START]    = {pattern_ap_start,    sizeof(pattern_ap_start) / sizeof(buzzer_step_t)},
+    [BUZZER_PATTERN_CARD_READ]   = {pattern_card_read,   sizeof(pattern_card_read) / sizeof(buzzer_step_t)},
+    [BUZZER_PATTERN_CARD_ADD]    = {pattern_card_add,    sizeof(pattern_card_add) / sizeof(buzzer_step_t)},
+    [BUZZER_PATTERN_CARD_DENIED] = {pattern_card_denied, sizeof(pattern_card_denied) / sizeof(buzzer_step_t)},
+};
+
+static void buzzer_on(void)  { gpio_set_level(BUZZER_GPIO, 1); }
+static void buzzer_off(void) { gpio_set_level(BUZZER_GPIO, 0); }
+
+static void buzzer_execute(buzzer_pattern_id_t pattern_id) {
+    if ((int)pattern_id <= BUZZER_PATTERN_NONE || pattern_id >= BUZZER_PATTERN_MAX) {
+        ESP_LOGW(TAG, "Invalid buzzer pattern id: %d", pattern_id);
+        return;
+    }
+
+    ESP_LOGD(TAG, "Executing buzzer pattern ID: %d", pattern_id);
+    const buzzer_pattern_t *pattern = &buzzer_patterns[pattern_id];
+    for (size_t i = 0; i < pattern->length; i++) {
+        buzzer_on();
+        vTaskDelay(pdMS_TO_TICKS(pattern->steps[i].on_ms));
+        buzzer_off();
+        if (pattern->steps[i].off_ms > 0) {
+            vTaskDelay(pdMS_TO_TICKS(pattern->steps[i].off_ms));
+        }
+    }
+}
+
+static void buzzer_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data) {
+    if (base != BUZZER_EVENTS || id != BUZZER_EVENT_PLAY_PATTERN || data == NULL) return;
+
+    buzzer_event_data_t *evt = (buzzer_event_data_t *)data;
+    if ((int)evt->pattern < BUZZER_PATTERN_NONE || evt->pattern >= BUZZER_PATTERN_MAX) {
+        ESP_LOGW(TAG, "Invalid buzzer pattern received: %d", evt->pattern);
+        return;
+    }
+
+    buzzer_execute(evt->pattern);
+}
+
+static void evse_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data) {
+    if (base != EVSE_EVENTS || id != EVSE_EVENT_STATE_CHANGED || data == NULL) return;
+
+    const evse_state_event_data_t *evt = (const evse_state_event_data_t *)data;
+    ESP_LOGD(TAG, "EVSE event received: state = %d", evt->state);
+
+    buzzer_event_data_t buzzer_evt = {0};
+
+    switch (evt->state) {
+        case EVSE_STATE_EVENT_IDLE:
+            buzzer_evt.pattern = BUZZER_PATTERN_UNPLUGGED;
+            break;
+        case EVSE_STATE_EVENT_WAITING:
+            buzzer_evt.pattern = BUZZER_PATTERN_PLUGGED;
+            break;
+        case EVSE_STATE_EVENT_CHARGING:
+            buzzer_evt.pattern = BUZZER_PATTERN_CHARGING;
+            break;
+        case EVSE_STATE_EVENT_FAULT:
+        default:
+            return;
+    }
+
+    esp_event_post(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, &buzzer_evt, sizeof(buzzer_evt), portMAX_DELAY);
+}
+
+static void network_event_handler(void *handler_args, esp_event_base_t base, int32_t id, void *event_data) {
+    if (id == NETWORK_EVENT_AP_STARTED) {
+        buzzer_event_data_t evt = {
+            .pattern = BUZZER_PATTERN_AP_START
+        };
+        esp_event_post(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, &evt, sizeof(evt), portMAX_DELAY);
+    }
+}
+
+
+static void auth_event_handler(void *arg, esp_event_base_t base, int32_t id, void *event_data) {
+    if (base != AUTH_EVENTS || event_data == NULL) return;
+
+    buzzer_event_data_t buzzer_evt = {0};
+
+    if (id == AUTH_EVENT_TAG_PROCESSED) {
+        const auth_tag_event_data_t *evt = (const auth_tag_event_data_t *)event_data;
+        ESP_LOGD(TAG, "AUTH processed: tag=%s authorized=%d", evt->tag, evt->authorized);
+        buzzer_evt.pattern = evt->authorized ? BUZZER_PATTERN_CARD_READ : BUZZER_PATTERN_CARD_DENIED;
+
+    } else if (id == AUTH_EVENT_TAG_SAVED) {
+        buzzer_evt.pattern = BUZZER_PATTERN_CARD_ADD;
+    } else {
+        return;
+    }
+
+    esp_event_post(BUZZER_EVENTS, BUZZER_EVENT_PLAY_PATTERN, &buzzer_evt, sizeof(buzzer_evt), portMAX_DELAY);
+}
+
+void buzzer_init(void) {
+    gpio_config_t io = {
+        .pin_bit_mask = BIT64(BUZZER_GPIO),
+        .mode = GPIO_MODE_OUTPUT,
+        .pull_down_en = 0,
+        .pull_up_en = 0,
+        .intr_type = GPIO_INTR_DISABLE
+    };
+    gpio_config(&io);
+    buzzer_off();
+
+    // Registro de handlers
+    ESP_ERROR_CHECK(esp_event_handler_register(BUZZER_EVENTS,
+                                               BUZZER_EVENT_PLAY_PATTERN,
+                                               buzzer_event_handler,
+                                               NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(EVSE_EVENTS,
+                                               EVSE_EVENT_STATE_CHANGED,
+                                               evse_event_handler,
+                                               NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS,
+                                               AUTH_EVENT_TAG_PROCESSED,
+                                               auth_event_handler,
+                                               NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS,
+                                               AUTH_EVENT_TAG_SAVED,
+                                               auth_event_handler,
+                                               NULL));
+
+    ESP_ERROR_CHECK(esp_event_handler_register(
+        NETWORK_EVENTS,
+        NETWORK_EVENT_AP_STARTED,
+        network_event_handler,
+        NULL
+    ));
+
+
+    ESP_LOGI(TAG, "Buzzer initialized on GPIO %d", BUZZER_GPIO);
+}

components/buzzer/src/buzzer_events.c

@@ -0,0 +1,3 @@
+#include "buzzer_events.h"
+
+ESP_EVENT_DEFINE_BASE(BUZZER_EVENTS);