8614 lines
242 KiB
C
Executable File
8614 lines
242 KiB
C
Executable File
|
|
|
|
// === Início de: main/main.c ===
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/event_groups.h"
|
|
|
|
#include "esp_log.h"
|
|
#include "esp_err.h"
|
|
#include "esp_event.h"
|
|
#include "esp_netif.h"
|
|
#include "esp_spiffs.h"
|
|
#include "esp_system.h"
|
|
#include "nvs_flash.h"
|
|
#include "driver/gpio.h"
|
|
|
|
#include "wifi.h"
|
|
#include "board_config.h"
|
|
#include "logger.h"
|
|
#include "rest_main.h"
|
|
|
|
#include "peripherals.h"
|
|
#include "protocols.h"
|
|
#include "evse_manager.h"
|
|
#include "evse_api.h"
|
|
#include "auth.h"
|
|
#include "loadbalancer.h"
|
|
#include "meter_manager.h"
|
|
|
|
|
|
#define EVSE_MANAGER_TICK_PERIOD_MS 1000
|
|
#define AP_CONNECTION_TIMEOUT 120000
|
|
#define RESET_HOLD_TIME 10000
|
|
#define DEBOUNCE_TIME_MS 50
|
|
|
|
#define PRESS_BIT BIT0
|
|
#define RELEASED_BIT BIT1
|
|
|
|
static const char *TAG = "app_main";
|
|
|
|
static TaskHandle_t user_input_task;
|
|
static TickType_t press_tick = 0;
|
|
static TickType_t last_interrupt_tick = 0;
|
|
static bool pressed = false;
|
|
|
|
|
|
//
|
|
// File system (SPIFFS) init and info
|
|
//
|
|
static void fs_info(esp_vfs_spiffs_conf_t *conf) {
|
|
size_t total = 0, used = 0;
|
|
esp_err_t ret = esp_spiffs_info(conf->partition_label, &total, &used);
|
|
if (ret == ESP_OK)
|
|
ESP_LOGI(TAG, "Partition %s: total: %d, used: %d", conf->partition_label, total, used);
|
|
else
|
|
ESP_LOGE(TAG, "Failed to get SPIFFS info: %s", esp_err_to_name(ret));
|
|
}
|
|
|
|
static void fs_init(void) {
|
|
esp_vfs_spiffs_conf_t cfg_conf = {
|
|
.base_path = "/cfg",
|
|
.partition_label = "cfg",
|
|
.max_files = 1,
|
|
.format_if_mount_failed = false
|
|
};
|
|
|
|
esp_vfs_spiffs_conf_t data_conf = {
|
|
.base_path = "/data",
|
|
.partition_label = "data",
|
|
.max_files = 5,
|
|
.format_if_mount_failed = true
|
|
};
|
|
|
|
ESP_ERROR_CHECK(esp_vfs_spiffs_register(&cfg_conf));
|
|
ESP_ERROR_CHECK(esp_vfs_spiffs_register(&data_conf));
|
|
|
|
fs_info(&cfg_conf);
|
|
fs_info(&data_conf);
|
|
}
|
|
|
|
//
|
|
// Wi-Fi event monitoring task
|
|
//
|
|
static void wifi_event_task_func(void *param) {
|
|
EventBits_t mode_bits;
|
|
while (1) {
|
|
mode_bits = xEventGroupWaitBits(wifi_event_group, WIFI_AP_MODE_BIT | WIFI_STA_MODE_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
|
|
|
|
if (mode_bits & WIFI_AP_MODE_BIT) {
|
|
if (xEventGroupWaitBits(wifi_event_group, WIFI_AP_CONNECTED_BIT, pdFALSE, pdFALSE, pdMS_TO_TICKS(AP_CONNECTION_TIMEOUT)) & WIFI_AP_CONNECTED_BIT) {
|
|
xEventGroupWaitBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
|
|
} else {
|
|
if (xEventGroupGetBits(wifi_event_group) & WIFI_AP_MODE_BIT) {
|
|
//wifi_ap_stop();
|
|
}
|
|
}
|
|
} else if (mode_bits & WIFI_STA_MODE_BIT) {
|
|
xEventGroupWaitBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Botão e tratamento
|
|
//
|
|
static void handle_button_press(void) {
|
|
ESP_LOGI(TAG, "Ativando modo AP");
|
|
if (!(xEventGroupGetBits(wifi_event_group) & WIFI_AP_MODE_BIT)) {
|
|
wifi_ap_start();
|
|
}
|
|
}
|
|
|
|
static void user_input_task_func(void *param) {
|
|
uint32_t notification;
|
|
while (1) {
|
|
if (xTaskNotifyWait(0x00, 0xFF, ¬ification, portMAX_DELAY)) {
|
|
if (notification & PRESS_BIT) {
|
|
press_tick = xTaskGetTickCount();
|
|
pressed = true;
|
|
ESP_LOGI(TAG, "Botão pressionado");
|
|
}
|
|
|
|
if (notification & RELEASED_BIT && pressed) {
|
|
pressed = false;
|
|
ESP_LOGI(TAG, "Botão liberado");
|
|
handle_button_press();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void IRAM_ATTR button_isr_handler(void *arg) {
|
|
BaseType_t higher_task_woken = pdFALSE;
|
|
TickType_t now = xTaskGetTickCountFromISR();
|
|
|
|
if (now - last_interrupt_tick < pdMS_TO_TICKS(DEBOUNCE_TIME_MS)) return;
|
|
last_interrupt_tick = now;
|
|
|
|
if (!gpio_get_level(board_config.button_wifi_gpio)) {
|
|
xTaskNotifyFromISR(user_input_task, RELEASED_BIT, eSetBits, &higher_task_woken);
|
|
} else {
|
|
xTaskNotifyFromISR(user_input_task, PRESS_BIT, eSetBits, &higher_task_woken);
|
|
}
|
|
|
|
if (higher_task_woken) {
|
|
portYIELD_FROM_ISR();
|
|
}
|
|
}
|
|
|
|
static void button_init(void) {
|
|
gpio_config_t conf = {
|
|
.pin_bit_mask = BIT64(board_config.button_wifi_gpio),
|
|
.mode = GPIO_MODE_INPUT,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.pull_up_en = GPIO_PULLUP_ENABLE,
|
|
.intr_type = GPIO_INTR_ANYEDGE
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&conf));
|
|
ESP_ERROR_CHECK(gpio_isr_handler_add(board_config.button_wifi_gpio, button_isr_handler, NULL));
|
|
}
|
|
|
|
//
|
|
// Inicialização dos módulos do sistema
|
|
//
|
|
static void init_modules(void) {
|
|
peripherals_init();
|
|
//api_init();
|
|
ESP_ERROR_CHECK(rest_server_init("/data"));
|
|
protocols_init();
|
|
evse_manager_init();
|
|
evse_init(); // Cria a task para FSM
|
|
button_init();
|
|
auth_init();
|
|
loadbalancer_init();
|
|
meter_manager_grid_init();
|
|
meter_manager_grid_start();
|
|
//meter_manager_evse_init();
|
|
|
|
// Outros módulos (descomente conforme necessário)
|
|
// meter_init();
|
|
// ocpp_start();
|
|
// orno_modbus_start();
|
|
// currentshaper_start();
|
|
// initWiegand();
|
|
// meter_zigbee_start();
|
|
// master_sync_start();
|
|
// slave_sync_start();
|
|
}
|
|
|
|
//
|
|
// Função principal do firmware
|
|
//
|
|
void app_main(void) {
|
|
logger_init();
|
|
esp_log_set_vprintf(logger_vprintf);
|
|
|
|
esp_reset_reason_t reason = esp_reset_reason();
|
|
ESP_LOGI(TAG, "Reset reason: %d", reason);
|
|
|
|
esp_err_t ret = nvs_flash_init();
|
|
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
|
ESP_LOGW(TAG, "Erasing NVS flash");
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
ret = nvs_flash_init();
|
|
}
|
|
ESP_ERROR_CHECK(ret);
|
|
|
|
fs_init();
|
|
ESP_ERROR_CHECK(esp_netif_init());
|
|
ESP_ERROR_CHECK(esp_event_loop_create_default());
|
|
ESP_ERROR_CHECK(gpio_install_isr_service(0));
|
|
|
|
board_config_load();
|
|
wifi_ini();
|
|
//wifi_ap_start();
|
|
init_modules();
|
|
|
|
xTaskCreate(wifi_event_task_func, "wifi_event_task", 8 * 1024, NULL, 3, NULL);
|
|
xTaskCreate(user_input_task_func, "user_input_task", 4 * 1024, NULL, 3, &user_input_task);
|
|
}
|
|
|
|
// === Fim de: main/main.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_pilot.c ===
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
#include "driver/ledc.h"
|
|
#include "esp_err.h"
|
|
#include "esp_log.h"
|
|
#include "esp_rom_sys.h"
|
|
|
|
#include "evse_pilot.h"
|
|
#include "adc.h"
|
|
#include "board_config.h"
|
|
|
|
#define PILOT_PWM_TIMER LEDC_TIMER_0
|
|
#define PILOT_PWM_CHANNEL LEDC_CHANNEL_0
|
|
#define PILOT_PWM_SPEED_MODE LEDC_LOW_SPEED_MODE
|
|
#define PILOT_PWM_DUTY_RES LEDC_TIMER_10_BIT
|
|
#define PILOT_PWM_MAX_DUTY 1023
|
|
|
|
#define NUM_PILOT_SAMPLES 100
|
|
#define MAX_SAMPLE_ATTEMPTS 1000
|
|
#define PILOT_EXTREME_PERCENT 10 // 10% superior e inferior
|
|
|
|
static const char *TAG = "evse_pilot";
|
|
|
|
void pilot_init(void)
|
|
{
|
|
ledc_timer_config_t ledc_timer = {
|
|
.speed_mode = PILOT_PWM_SPEED_MODE,
|
|
.timer_num = PILOT_PWM_TIMER,
|
|
.duty_resolution = PILOT_PWM_DUTY_RES,
|
|
.freq_hz = 1000,
|
|
.clk_cfg = LEDC_AUTO_CLK
|
|
};
|
|
ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));
|
|
|
|
ledc_channel_config_t ledc_channel = {
|
|
.speed_mode = PILOT_PWM_SPEED_MODE,
|
|
.channel = PILOT_PWM_CHANNEL,
|
|
.timer_sel = PILOT_PWM_TIMER,
|
|
.intr_type = LEDC_INTR_DISABLE,
|
|
.gpio_num = board_config.pilot_pwm_gpio,
|
|
.duty = 0,
|
|
.hpoint = 0
|
|
};
|
|
ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel));
|
|
ESP_ERROR_CHECK(ledc_stop(PILOT_PWM_SPEED_MODE, PILOT_PWM_CHANNEL, 0));
|
|
|
|
ESP_ERROR_CHECK(ledc_fade_func_install(0));
|
|
|
|
adc_oneshot_chan_cfg_t config = {
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
};
|
|
|
|
ESP_ERROR_CHECK(adc_oneshot_config_channel(adc_handle, board_config.pilot_adc_channel, &config));
|
|
}
|
|
|
|
void pilot_set_level(bool level)
|
|
{
|
|
ESP_LOGI(TAG, "Set level %d", level);
|
|
ledc_stop(PILOT_PWM_SPEED_MODE, PILOT_PWM_CHANNEL, level ? 1 : 0);
|
|
}
|
|
|
|
void pilot_set_amps(uint16_t amps)
|
|
{
|
|
ESP_LOGI(TAG, "Set amps %d", amps);
|
|
|
|
if (amps < 60 || amps > 800) {
|
|
ESP_LOGE(TAG, "Invalid ampere value: %d A*10", amps);
|
|
return;
|
|
}
|
|
|
|
uint32_t duty;
|
|
if (amps <= 510) {
|
|
duty = (PILOT_PWM_MAX_DUTY * amps) / 600;
|
|
} else {
|
|
duty = ((PILOT_PWM_MAX_DUTY * amps) / 2500) + (64 * (PILOT_PWM_MAX_DUTY / 100));
|
|
}
|
|
|
|
if (duty > PILOT_PWM_MAX_DUTY)
|
|
duty = PILOT_PWM_MAX_DUTY;
|
|
|
|
ESP_LOGI(TAG, "Set amp %dA*10 -> duty %lu/%d", amps, duty, PILOT_PWM_MAX_DUTY);
|
|
ledc_set_duty(PILOT_PWM_SPEED_MODE, PILOT_PWM_CHANNEL, duty);
|
|
ledc_update_duty(PILOT_PWM_SPEED_MODE, PILOT_PWM_CHANNEL);
|
|
}
|
|
static int compare_int(const void *a, const void *b) {
|
|
return (*(int *)a - *(int *)b);
|
|
}
|
|
|
|
static int select_low_median_qsort(int *src, int n, int percent) {
|
|
int k = (n * percent) / 100;
|
|
if (k == 0) k = 1;
|
|
|
|
int *copy = alloca(n * sizeof(int));
|
|
memcpy(copy, src, n * sizeof(int));
|
|
|
|
qsort(copy, n, sizeof(int), compare_int);
|
|
return copy[k / 2];
|
|
}
|
|
|
|
static int select_high_median_qsort(int *src, int n, int percent) {
|
|
int k = (n * percent) / 100;
|
|
if (k == 0) k = 1;
|
|
|
|
int *copy = alloca(n * sizeof(int));
|
|
memcpy(copy, src, n * sizeof(int));
|
|
|
|
qsort(copy, n, sizeof(int), compare_int);
|
|
return copy[n - k + (k / 2)];
|
|
}
|
|
|
|
void pilot_measure(pilot_voltage_t *up_voltage, bool *down_voltage_n12)
|
|
{
|
|
ESP_LOGD(TAG, "pilot_measure");
|
|
|
|
int samples[NUM_PILOT_SAMPLES];
|
|
int collected = 0, attempts = 0;
|
|
int sample;
|
|
|
|
while (collected < NUM_PILOT_SAMPLES && attempts < MAX_SAMPLE_ATTEMPTS) {
|
|
if (adc_oneshot_read(adc_handle, board_config.pilot_adc_channel, &sample) == ESP_OK) {
|
|
samples[collected++] = sample;
|
|
esp_rom_delay_us(10);
|
|
} else {
|
|
esp_rom_delay_us(100);
|
|
attempts++;
|
|
}
|
|
}
|
|
|
|
if (collected < NUM_PILOT_SAMPLES) {
|
|
ESP_LOGW(TAG, "Timeout on sample read (%d/%d)", collected, NUM_PILOT_SAMPLES);
|
|
*up_voltage = PILOT_VOLTAGE_1;
|
|
*down_voltage_n12 = false;
|
|
return;
|
|
}
|
|
|
|
int high_raw = select_high_median_qsort(samples, collected, PILOT_EXTREME_PERCENT);
|
|
int low_raw = select_low_median_qsort(samples, collected, PILOT_EXTREME_PERCENT);
|
|
|
|
|
|
ESP_LOGD(TAG, "Final: high_raw=%d, low_raw=%d", high_raw, low_raw);
|
|
|
|
int high_mv = 0;
|
|
int low_mv = 0;
|
|
|
|
if (adc_cali_raw_to_voltage(adc_cali_handle, high_raw, &high_mv) != ESP_OK ||
|
|
adc_cali_raw_to_voltage(adc_cali_handle, low_raw, &low_mv) != ESP_OK) {
|
|
ESP_LOGW(TAG, "ADC calibration failed");
|
|
*up_voltage = PILOT_VOLTAGE_1;
|
|
*down_voltage_n12 = false;
|
|
return;
|
|
}
|
|
|
|
if (high_mv >= board_config.pilot_down_threshold_12)
|
|
*up_voltage = PILOT_VOLTAGE_12;
|
|
else if (high_mv >= board_config.pilot_down_threshold_9)
|
|
*up_voltage = PILOT_VOLTAGE_9;
|
|
else if (high_mv >= board_config.pilot_down_threshold_6)
|
|
*up_voltage = PILOT_VOLTAGE_6;
|
|
else if (high_mv >= board_config.pilot_down_threshold_3)
|
|
*up_voltage = PILOT_VOLTAGE_3;
|
|
else
|
|
*up_voltage = PILOT_VOLTAGE_1;
|
|
|
|
*down_voltage_n12 = (low_mv <= board_config.pilot_down_threshold_n12);
|
|
|
|
ESP_LOGD(TAG, "Final: up_voltage=%d, down_voltage_n12=%d", *up_voltage, *down_voltage_n12);
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_pilot.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_hardware.c ===
|
|
#include "evse_hardware.h"
|
|
#include "evse_pilot.h"
|
|
#include "ac_relay.h"
|
|
#include "socket_lock.h"
|
|
#include "proximity.h"
|
|
|
|
static const char *TAG = "evse_hardware";
|
|
|
|
void evse_hardware_init(void) {
|
|
pilot_init();
|
|
pilot_set_level(true); // Sinal piloto em 12V (inicial)
|
|
ac_relay_set_state(false); // Relé desligado
|
|
//socket_lock_set_locked(false); // Destrava o conector
|
|
}
|
|
|
|
void evse_hardware_tick(void) {
|
|
// Tick para atualizações de hardware com polling, se necessário
|
|
}
|
|
|
|
bool evse_hardware_is_pilot_high(void) {
|
|
return pilot_get_state(); // true se sinal piloto estiver em nível alto
|
|
}
|
|
|
|
bool evse_hardware_is_vehicle_connected(void) {
|
|
// Verifica se o veículo está conectado pelo resistor do pino PP
|
|
return proximity_get_max_current() > 0;
|
|
}
|
|
|
|
bool evse_hardware_is_energy_detected(void) {
|
|
return false;
|
|
}
|
|
|
|
void evse_hardware_relay_on(void) {
|
|
ac_relay_set_state(true);
|
|
}
|
|
|
|
void evse_hardware_relay_off(void) {
|
|
ac_relay_set_state(false);
|
|
}
|
|
|
|
bool evse_hardware_relay_status(void) {
|
|
return ac_relay_get_state();
|
|
}
|
|
|
|
void evse_hardware_lock(void) {
|
|
socket_lock_set_locked(true);
|
|
}
|
|
|
|
void evse_hardware_unlock(void) {
|
|
socket_lock_set_locked(false);
|
|
}
|
|
|
|
bool evse_hardware_is_locked(void) {
|
|
return socket_lock_is_locked_state();
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_hardware.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_state.c ===
|
|
#include "evse_state.h"
|
|
#include "evse_events.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/portmacro.h"
|
|
#include "esp_log.h"
|
|
|
|
static evse_state_t current_state = EVSE_STATE_A;
|
|
static bool is_authorized = false;
|
|
|
|
// Proteção básica para variáveis globais em sistemas concorrentes
|
|
static portMUX_TYPE state_mux = portMUX_INITIALIZER_UNLOCKED;
|
|
|
|
static evse_state_event_t map_state_to_event(evse_state_t s) {
|
|
switch (s) {
|
|
case EVSE_STATE_A:
|
|
return EVSE_STATE_EVENT_IDLE;
|
|
case EVSE_STATE_B1:
|
|
return EVSE_STATE_EVENT_WAITING;
|
|
case EVSE_STATE_B2:
|
|
case EVSE_STATE_C1:
|
|
case EVSE_STATE_C2:
|
|
return EVSE_STATE_EVENT_CHARGING;
|
|
case EVSE_STATE_E:
|
|
case EVSE_STATE_F:
|
|
return EVSE_STATE_EVENT_FAULT;
|
|
default:
|
|
return EVSE_STATE_EVENT_IDLE;
|
|
}
|
|
}
|
|
void evse_set_state(evse_state_t state) {
|
|
bool changed = false;
|
|
evse_state_t previous_state;
|
|
|
|
portENTER_CRITICAL(&state_mux);
|
|
previous_state = current_state;
|
|
if (state != current_state) {
|
|
current_state = state;
|
|
changed = true;
|
|
}
|
|
portEXIT_CRITICAL(&state_mux);
|
|
|
|
if (changed) {
|
|
ESP_LOGI("EVSE_STATE", "Estado alterado de %s para %s",
|
|
evse_state_to_str(previous_state),
|
|
evse_state_to_str(state));
|
|
|
|
evse_state_event_data_t evt = {
|
|
.state = map_state_to_event(state)
|
|
};
|
|
esp_event_post(EVSE_EVENTS, EVSE_EVENT_STATE_CHANGED, &evt, sizeof(evt), portMAX_DELAY);
|
|
}
|
|
}
|
|
|
|
evse_state_t evse_get_state(void) {
|
|
portENTER_CRITICAL(&state_mux);
|
|
evse_state_t s = current_state;
|
|
portEXIT_CRITICAL(&state_mux);
|
|
return s;
|
|
}
|
|
|
|
const char* evse_state_to_str(evse_state_t state) {
|
|
switch (state) {
|
|
case EVSE_STATE_A: return "A - EV Not Connected (12V)";
|
|
case EVSE_STATE_B1: return "B1 - EV Connected (9V, Not Authorized)";
|
|
case EVSE_STATE_B2: return "B2 - EV Connected (9V, Authorized and Ready)";
|
|
case EVSE_STATE_C1: return "C1 - Charging Requested (6V, Relay Off)";
|
|
case EVSE_STATE_C2: return "C2 - Charging Active (6V, Relay On)";
|
|
case EVSE_STATE_D1: return "D1 - Ventilation Required (3V, Relay Off)";
|
|
case EVSE_STATE_D2: return "D2 - Ventilation Active (3V, Relay On)";
|
|
case EVSE_STATE_E: return "E - Error: Control Pilot Shorted to Ground (0V)";
|
|
case EVSE_STATE_F: return "F - Fault: EVSE Unavailable or No Pilot Signal";
|
|
default: return "Unknown State";
|
|
}
|
|
}
|
|
|
|
void evse_state_init(void) {
|
|
portENTER_CRITICAL(&state_mux);
|
|
current_state = EVSE_STATE_A;
|
|
is_authorized = true;
|
|
portEXIT_CRITICAL(&state_mux);
|
|
|
|
ESP_LOGI("EVSE_STATE", "Inicializado em estado: %s", evse_state_to_str(current_state));
|
|
|
|
evse_state_event_data_t evt = {
|
|
.state = map_state_to_event(current_state)
|
|
};
|
|
esp_event_post(EVSE_EVENTS, EVSE_EVENT_INIT, &evt, sizeof(evt), portMAX_DELAY);
|
|
}
|
|
|
|
void evse_state_tick(void) {
|
|
// Tick do estado (placeholder)
|
|
}
|
|
|
|
bool evse_state_is_charging(evse_state_t state) {
|
|
return state == EVSE_STATE_C1 || state == EVSE_STATE_C2;
|
|
}
|
|
|
|
bool evse_state_is_plugged(evse_state_t state) {
|
|
return state == EVSE_STATE_B1 || state == EVSE_STATE_B2 ||
|
|
state == EVSE_STATE_C1 || state == EVSE_STATE_C2 ||
|
|
state == EVSE_STATE_D1 || state == EVSE_STATE_D2;
|
|
}
|
|
|
|
bool evse_state_is_session(evse_state_t state) {
|
|
return state == EVSE_STATE_B2 || state == EVSE_STATE_C1 || state == EVSE_STATE_C2;
|
|
}
|
|
|
|
void evse_state_set_authorized(bool authorized) {
|
|
portENTER_CRITICAL(&state_mux);
|
|
is_authorized = authorized;
|
|
portEXIT_CRITICAL(&state_mux);
|
|
}
|
|
|
|
bool evse_state_get_authorized(void) {
|
|
portENTER_CRITICAL(&state_mux);
|
|
bool result = is_authorized;
|
|
portEXIT_CRITICAL(&state_mux);
|
|
return result;
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_state.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_fsm.c ===
|
|
// evse_fsm.c - Máquina de Estados EVSE com controle centralizado
|
|
|
|
#include "evse_fsm.h"
|
|
#include "evse_api.h"
|
|
#include "evse_pilot.h"
|
|
#include "evse_config.h"
|
|
#include "esp_log.h"
|
|
#include "ac_relay.h"
|
|
#include "board_config.h"
|
|
#include "socket_lock.h"
|
|
#include "proximity.h"
|
|
#include "rcm.h"
|
|
#include "evse_state.h"
|
|
|
|
static const char *TAG = "evse_fsm";
|
|
|
|
#ifndef MIN
|
|
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
#endif
|
|
|
|
static bool c1_d1_waiting = false;
|
|
static TickType_t c1_d1_relay_to = 0;
|
|
|
|
void evse_fsm_reset(void) {
|
|
evse_set_state(EVSE_STATE_A);
|
|
c1_d1_waiting = false;
|
|
c1_d1_relay_to = 0;
|
|
}
|
|
|
|
static void update_outputs(evse_state_t state) {
|
|
const uint16_t current = evse_get_runtime_charging_current();
|
|
uint8_t cable_max_current = evse_get_max_charging_current();
|
|
const bool socket_outlet = evse_get_socket_outlet();
|
|
|
|
if (socket_outlet) {
|
|
cable_max_current = proximity_get_max_current();
|
|
}
|
|
|
|
switch (state) {
|
|
case EVSE_STATE_A:
|
|
case EVSE_STATE_E:
|
|
case EVSE_STATE_F:
|
|
ac_relay_set_state(false);
|
|
pilot_set_level(state == EVSE_STATE_A);
|
|
if (board_config.socket_lock && socket_outlet) {
|
|
socket_lock_set_locked(false);
|
|
}
|
|
break;
|
|
|
|
case EVSE_STATE_B1:
|
|
pilot_set_level(true);
|
|
ac_relay_set_state(false);
|
|
if (board_config.socket_lock && socket_outlet) {
|
|
socket_lock_set_locked(true);
|
|
}
|
|
|
|
if (rcm_test()) {
|
|
ESP_LOGI(TAG, "RCM self test passed");
|
|
} else {
|
|
ESP_LOGW(TAG, "RCM self test failed");
|
|
}
|
|
break;
|
|
|
|
case EVSE_STATE_B2:
|
|
pilot_set_amps(MIN(current * 10, cable_max_current * 10));
|
|
ac_relay_set_state(false);
|
|
break;
|
|
|
|
case EVSE_STATE_C1:
|
|
case EVSE_STATE_D1:
|
|
pilot_set_level(true);
|
|
c1_d1_waiting = true;
|
|
c1_d1_relay_to = xTaskGetTickCount() + pdMS_TO_TICKS(6000);
|
|
break;
|
|
|
|
case EVSE_STATE_C2:
|
|
case EVSE_STATE_D2:
|
|
pilot_set_amps(MIN(current * 10, cable_max_current * 10));
|
|
ac_relay_set_state(true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void evse_fsm_process(pilot_voltage_t pilot_voltage, bool authorized, bool available, bool enabled) {
|
|
TickType_t now = xTaskGetTickCount();
|
|
evse_state_t prev = evse_get_state();
|
|
evse_state_t curr = prev;
|
|
|
|
switch (curr) {
|
|
case EVSE_STATE_A:
|
|
if (!available) {
|
|
evse_set_state(EVSE_STATE_F);
|
|
} else if (pilot_voltage == PILOT_VOLTAGE_9) {
|
|
evse_set_state(EVSE_STATE_B1);
|
|
}
|
|
break;
|
|
|
|
case EVSE_STATE_B1:
|
|
case EVSE_STATE_B2:
|
|
if (!available) {
|
|
evse_set_state(EVSE_STATE_F);
|
|
break;
|
|
}
|
|
|
|
switch (pilot_voltage) {
|
|
case PILOT_VOLTAGE_12:
|
|
evse_set_state(EVSE_STATE_A);
|
|
break;
|
|
case PILOT_VOLTAGE_9:
|
|
evse_set_state((authorized && enabled) ? EVSE_STATE_B2 : EVSE_STATE_B1);
|
|
break;
|
|
case PILOT_VOLTAGE_6:
|
|
evse_set_state((authorized && enabled) ? EVSE_STATE_C2 : EVSE_STATE_C1);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case EVSE_STATE_C1:
|
|
case EVSE_STATE_D1:
|
|
if (c1_d1_waiting && now >= c1_d1_relay_to) {
|
|
ac_relay_set_state(false);
|
|
c1_d1_waiting = false;
|
|
if (!available) {
|
|
evse_set_state(EVSE_STATE_F);
|
|
break;
|
|
}
|
|
}
|
|
__attribute__((fallthrough)); // Evita warning de fallthrough implícito
|
|
|
|
case EVSE_STATE_C2:
|
|
case EVSE_STATE_D2:
|
|
if (!enabled || !available) {
|
|
evse_set_state((curr == EVSE_STATE_D2 || curr == EVSE_STATE_D1) ? EVSE_STATE_D1 : EVSE_STATE_C1);
|
|
break;
|
|
}
|
|
|
|
switch (pilot_voltage) {
|
|
case PILOT_VOLTAGE_6:
|
|
evse_set_state((authorized && enabled) ? EVSE_STATE_C2 : EVSE_STATE_C1);
|
|
break;
|
|
case PILOT_VOLTAGE_3:
|
|
evse_set_state((authorized && enabled) ? EVSE_STATE_D2 : EVSE_STATE_D1);
|
|
break;
|
|
case PILOT_VOLTAGE_9:
|
|
evse_set_state((authorized && enabled) ? EVSE_STATE_B2 : EVSE_STATE_B1);
|
|
break;
|
|
case PILOT_VOLTAGE_12:
|
|
evse_set_state(EVSE_STATE_A);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case EVSE_STATE_E:
|
|
break; // Sem transições a partir de E
|
|
|
|
case EVSE_STATE_F:
|
|
if (available) {
|
|
evse_set_state(EVSE_STATE_A);
|
|
}
|
|
break;
|
|
}
|
|
|
|
evse_state_t next = evse_get_state();
|
|
if (next != prev) {
|
|
ESP_LOGI(TAG, "State changed: %s -> %s", evse_state_to_str(prev), evse_state_to_str(next));
|
|
update_outputs(next);
|
|
}
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_fsm.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_error.c ===
|
|
#include "evse_error.h"
|
|
#include "evse_config.h"
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "esp_log.h"
|
|
#include "ntc_sensor.h"
|
|
|
|
static const char *TAG = "evse_error";
|
|
|
|
static uint32_t error_bits = 0;
|
|
static TickType_t auto_clear_timeout = 0;
|
|
static bool error_cleared = false;
|
|
|
|
void evse_error_init(void) {
|
|
// Inicialização do sistema de erros
|
|
}
|
|
|
|
void evse_error_check(pilot_voltage_t pilot_voltage, bool is_n12v) {
|
|
ESP_LOGD(TAG, "Verificando erro: pilot_voltage = %d, is_n12v = %s",
|
|
pilot_voltage, is_n12v ? "true" : "false");
|
|
|
|
// Falha elétrica geral no pilot
|
|
if (pilot_voltage == PILOT_VOLTAGE_1) {
|
|
if (!(error_bits & EVSE_ERR_PILOT_FAULT_BIT)) { // Verifica se o erro já foi registrado
|
|
evse_error_set(EVSE_ERR_PILOT_FAULT_BIT);
|
|
ESP_LOGW(TAG, "Erro: pilot abaixo de 2V (falha)");
|
|
}
|
|
}
|
|
|
|
// Falta de -12V durante PWM (C ou D)
|
|
if ((pilot_voltage == PILOT_VOLTAGE_6 || pilot_voltage == PILOT_VOLTAGE_3) && !is_n12v) {
|
|
if (!(error_bits & EVSE_ERR_DIODE_SHORT_BIT)) { // Verifica se o erro já foi registrado
|
|
evse_error_set(EVSE_ERR_DIODE_SHORT_BIT);
|
|
ESP_LOGW(TAG, "Erro: ausência de -12V no PWM (sem diodo)");
|
|
ESP_LOGW(TAG, "Verificando erro: pilot_voltage = %d, is_n12v = %s", pilot_voltage, is_n12v ? "true" : "false");
|
|
}
|
|
}
|
|
}
|
|
|
|
void evse_temperature_check(void) {
|
|
float temp_c = ntc_temp_sensor(); // leitura atual (última medida válida)
|
|
uint8_t threshold = evse_get_temp_threshold(); // padrão 60°C, configurável
|
|
|
|
// Log informativo com os valores
|
|
ESP_LOGD(TAG, "Verificando temperatura: atual = %.2f °C, limite = %d °C", temp_c, threshold);
|
|
|
|
// Se a temperatura parecer inválida, aplica erro de sensor
|
|
if (temp_c < -40.0f || temp_c > 150.0f) {
|
|
if (!(error_bits & EVSE_ERR_TEMPERATURE_FAULT_BIT)) { // Verifica se o erro já foi registrado
|
|
evse_error_set(EVSE_ERR_TEMPERATURE_FAULT_BIT);
|
|
ESP_LOGW(TAG, "Sensor NTC falhou ou está desconectado");
|
|
}
|
|
return;
|
|
}
|
|
|
|
evse_error_clear(EVSE_ERR_TEMPERATURE_FAULT_BIT); // leitura válida
|
|
|
|
if (temp_c >= threshold) {
|
|
if (!(error_bits & EVSE_ERR_TEMPERATURE_HIGH_BIT)) { // Verifica se o erro já foi registrado
|
|
evse_error_set(EVSE_ERR_TEMPERATURE_HIGH_BIT);
|
|
ESP_LOGW(TAG, "Temperatura acima do limite: %.2f °C ≥ %d °C", temp_c, threshold);
|
|
}
|
|
} else {
|
|
evse_error_clear(EVSE_ERR_TEMPERATURE_HIGH_BIT);
|
|
}
|
|
}
|
|
|
|
uint32_t evse_get_error(void) {
|
|
return error_bits;
|
|
}
|
|
|
|
bool evse_is_error_cleared(void) {
|
|
return error_cleared;
|
|
}
|
|
|
|
void evse_mark_error_cleared(void) {
|
|
error_cleared = false;
|
|
}
|
|
|
|
// Já existentes
|
|
void evse_error_set(uint32_t bitmask) {
|
|
error_bits |= bitmask;
|
|
|
|
if (bitmask & EVSE_ERR_AUTO_CLEAR_BITS) {
|
|
auto_clear_timeout = xTaskGetTickCount() + pdMS_TO_TICKS(60000); // 60s
|
|
}
|
|
}
|
|
|
|
void evse_error_clear(uint32_t bitmask) {
|
|
bool had_error = error_bits != 0;
|
|
error_bits &= ~bitmask;
|
|
|
|
if (had_error && error_bits == 0) {
|
|
error_cleared = true;
|
|
}
|
|
}
|
|
|
|
void evse_error_tick(void) {
|
|
if ((error_bits & EVSE_ERR_AUTO_CLEAR_BITS) && xTaskGetTickCount() >= auto_clear_timeout) {
|
|
evse_error_clear(EVSE_ERR_AUTO_CLEAR_BITS);
|
|
auto_clear_timeout = 0;
|
|
}
|
|
}
|
|
|
|
bool evse_error_is_active(void) {
|
|
return error_bits != 0;
|
|
}
|
|
|
|
uint32_t evse_error_get_bits(void) {
|
|
return error_bits;
|
|
}
|
|
|
|
void evse_error_reset_flag(void) {
|
|
error_cleared = false;
|
|
}
|
|
|
|
bool evse_error_cleared_flag(void) {
|
|
return error_cleared;
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_error.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_core.c ===
|
|
// evse_core.c - Função principal de controle do EVSE
|
|
|
|
#include "evse_fsm.h"
|
|
#include "evse_error.h"
|
|
#include "evse_limits.h"
|
|
#include "evse_config.h"
|
|
#include "evse_api.h"
|
|
#include "evse_pilot.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/semphr.h"
|
|
#include "esp_log.h"
|
|
|
|
static const char *TAG = "evse_core";
|
|
|
|
static SemaphoreHandle_t mutex;
|
|
|
|
static evse_state_t last_state = EVSE_STATE_A;
|
|
|
|
static void evse_core_task(void *arg);
|
|
|
|
void evse_init(void) {
|
|
ESP_LOGI(TAG, "EVSE Init");
|
|
|
|
mutex = xSemaphoreCreateMutex();
|
|
|
|
evse_check_defaults();
|
|
evse_fsm_reset();
|
|
pilot_set_level(true); // Estado inicial do piloto
|
|
|
|
xTaskCreate(evse_core_task, "evse_core_task", 4096, NULL, 5, NULL);
|
|
}
|
|
|
|
void evse_process(void) {
|
|
xSemaphoreTake(mutex, portMAX_DELAY);
|
|
|
|
pilot_voltage_t pilot_voltage;
|
|
bool is_n12v = false;
|
|
|
|
pilot_measure(&pilot_voltage, &is_n12v);
|
|
ESP_LOGD(TAG, "Pilot: %d, -12V: %s", pilot_voltage, is_n12v ? "yes" : "no");
|
|
|
|
if (evse_get_error() == 0 && !evse_is_error_cleared()) {
|
|
|
|
evse_error_check(pilot_voltage, is_n12v);
|
|
|
|
evse_fsm_process(
|
|
pilot_voltage,
|
|
evse_state_get_authorized(),
|
|
evse_config_is_available(),
|
|
evse_config_is_enabled()
|
|
);
|
|
|
|
evse_limits_check(evse_get_state());
|
|
|
|
evse_state_t current = evse_get_state();
|
|
if (current != last_state) {
|
|
ESP_LOGI(TAG, "State changed: %s → %s",
|
|
evse_state_to_str(last_state),
|
|
evse_state_to_str(current));
|
|
last_state = current;
|
|
}
|
|
|
|
evse_mark_error_cleared();
|
|
}
|
|
|
|
xSemaphoreGive(mutex);
|
|
}
|
|
|
|
|
|
// ================================
|
|
// Interface pública
|
|
// ================================
|
|
|
|
bool evse_is_enabled(void) {
|
|
return evse_config_is_enabled();
|
|
}
|
|
|
|
void evse_set_enabled(bool value) {
|
|
ESP_LOGI(TAG, "Set enabled %d", value);
|
|
evse_config_set_enabled(value);
|
|
}
|
|
|
|
bool evse_is_available(void) {
|
|
return evse_config_is_available();
|
|
}
|
|
|
|
void evse_set_available(bool value) {
|
|
ESP_LOGI(TAG, "Set available %d", value);
|
|
evse_config_set_available(value);
|
|
}
|
|
|
|
// ================================
|
|
// Tarefa principal
|
|
// ================================
|
|
|
|
static void evse_core_task(void *arg) {
|
|
while (true) {
|
|
evse_process();
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
}
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_core.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_limits.c ===
|
|
#include "evse_limits.h"
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
|
|
// ========================
|
|
// Estado interno
|
|
// ========================
|
|
|
|
static bool limit_reached = false;
|
|
static uint32_t consumption_limit = 0;
|
|
static uint32_t charging_time_limit = 0;
|
|
static uint16_t under_power_limit = 0;
|
|
|
|
static uint32_t default_consumption_limit = 0;
|
|
static uint32_t default_charging_time_limit = 0;
|
|
static uint16_t default_under_power_limit = 0;
|
|
|
|
// ========================
|
|
// Estado de controle
|
|
// ========================
|
|
|
|
void evse_set_limit_reached(uint8_t value) {
|
|
limit_reached = (value != 0);
|
|
}
|
|
|
|
bool evse_is_limit_reached(void) {
|
|
return limit_reached;
|
|
}
|
|
|
|
// ========================
|
|
// Limites em tempo de execução
|
|
// ========================
|
|
|
|
uint32_t evse_get_consumption_limit(void) {
|
|
return consumption_limit;
|
|
}
|
|
|
|
void evse_set_consumption_limit(uint32_t value) {
|
|
consumption_limit = value;
|
|
}
|
|
|
|
uint32_t evse_get_charging_time_limit(void) {
|
|
return charging_time_limit;
|
|
}
|
|
|
|
void evse_set_charging_time_limit(uint32_t value) {
|
|
charging_time_limit = value;
|
|
}
|
|
|
|
uint16_t evse_get_under_power_limit(void) {
|
|
return under_power_limit;
|
|
}
|
|
|
|
void evse_set_under_power_limit(uint16_t value) {
|
|
under_power_limit = value;
|
|
}
|
|
|
|
// ========================
|
|
// Limites padrão (persistentes)
|
|
// ========================
|
|
|
|
uint32_t evse_get_default_consumption_limit(void) {
|
|
return default_consumption_limit;
|
|
}
|
|
|
|
void evse_set_default_consumption_limit(uint32_t value) {
|
|
default_consumption_limit = value;
|
|
}
|
|
|
|
uint32_t evse_get_default_charging_time_limit(void) {
|
|
return default_charging_time_limit;
|
|
}
|
|
|
|
void evse_set_default_charging_time_limit(uint32_t value) {
|
|
default_charging_time_limit = value;
|
|
}
|
|
|
|
uint16_t evse_get_default_under_power_limit(void) {
|
|
return default_under_power_limit;
|
|
}
|
|
|
|
void evse_set_default_under_power_limit(uint16_t value) {
|
|
default_under_power_limit = value;
|
|
}
|
|
|
|
// ========================
|
|
// Lógica de verificação de limites
|
|
// ========================
|
|
|
|
void evse_limits_check(evse_state_t state) {
|
|
// Se algum limite estiver ativo, verifique o estado
|
|
if ((consumption_limit > 0 || charging_time_limit > 0 || under_power_limit > 0)
|
|
&& evse_state_is_charging(state)) {
|
|
// (Lógica real a ser aplicada aqui, ex: medição de consumo, tempo ou potência)
|
|
evse_set_limit_reached(1);
|
|
}
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_limits.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_config.c ===
|
|
#include <inttypes.h> // For PRI macros
|
|
#include "evse_config.h"
|
|
#include "board_config.h"
|
|
#include "evse_limits.h"
|
|
#include "esp_log.h"
|
|
#include "nvs.h"
|
|
|
|
static const char *TAG = "evse_config";
|
|
|
|
static nvs_handle_t nvs;
|
|
|
|
// ========================
|
|
// Configurable parameters
|
|
// ========================
|
|
static uint8_t max_charging_current = MAX_CHARGING_CURRENT_LIMIT;
|
|
static uint16_t charging_current; // Persisted (NVS)
|
|
static uint16_t charging_current_runtime = 0; // Runtime only
|
|
static bool socket_outlet;
|
|
static bool rcm;
|
|
static uint8_t temp_threshold = 60;
|
|
static bool require_auth;
|
|
|
|
// ========================
|
|
// Initialization
|
|
// ========================
|
|
esp_err_t evse_config_init(void) {
|
|
ESP_LOGD(TAG, "Initializing NVS configuration...");
|
|
return nvs_open("evse", NVS_READWRITE, &nvs);
|
|
}
|
|
|
|
void evse_check_defaults(void) {
|
|
esp_err_t err;
|
|
uint8_t u8;
|
|
uint16_t u16;
|
|
uint32_t u32;
|
|
bool needs_commit = false;
|
|
|
|
ESP_LOGD(TAG, "Checking default parameters...");
|
|
|
|
// Max charging current
|
|
err = nvs_get_u8(nvs, "max_chrg_curr", &u8);
|
|
if (err != ESP_OK || u8 < MIN_CHARGING_CURRENT_LIMIT || u8 > MAX_CHARGING_CURRENT_LIMIT) {
|
|
max_charging_current = MAX_CHARGING_CURRENT_LIMIT;
|
|
nvs_set_u8(nvs, "max_chrg_curr", max_charging_current);
|
|
needs_commit = true;
|
|
ESP_LOGW(TAG, "Invalid or missing max_chrg_curr, resetting to %d", max_charging_current);
|
|
} else {
|
|
max_charging_current = u8;
|
|
}
|
|
|
|
// Charging current (default, persisted)
|
|
err = nvs_get_u16(nvs, "def_chrg_curr", &u16);
|
|
if (err != ESP_OK || u16 < (MIN_CHARGING_CURRENT_LIMIT * 10) || u16 > (max_charging_current * 10)) {
|
|
charging_current = max_charging_current * 10;
|
|
nvs_set_u16(nvs, "def_chrg_curr", charging_current);
|
|
needs_commit = true;
|
|
ESP_LOGW(TAG, "Invalid or missing def_chrg_curr, resetting to %d", charging_current);
|
|
} else {
|
|
charging_current = u16;
|
|
}
|
|
|
|
// Runtime charging current initialized from persisted default
|
|
charging_current_runtime = charging_current;
|
|
ESP_LOGD(TAG, "Runtime charging current initialized to: %d", charging_current_runtime);
|
|
|
|
// Auth required
|
|
err = nvs_get_u8(nvs, "require_auth", &u8);
|
|
require_auth = (err == ESP_OK && u8 <= 1) ? u8 : false;
|
|
if (err != ESP_OK) {
|
|
nvs_set_u8(nvs, "require_auth", require_auth);
|
|
needs_commit = true;
|
|
}
|
|
|
|
// Socket outlet
|
|
err = nvs_get_u8(nvs, "socket_outlet", &u8);
|
|
socket_outlet = (err == ESP_OK && u8) && board_config.proximity;
|
|
if (err != ESP_OK) {
|
|
nvs_set_u8(nvs, "socket_outlet", socket_outlet);
|
|
needs_commit = true;
|
|
}
|
|
|
|
// RCM
|
|
err = nvs_get_u8(nvs, "rcm", &u8);
|
|
rcm = (err == ESP_OK && u8) && board_config.rcm;
|
|
if (err != ESP_OK) {
|
|
nvs_set_u8(nvs, "rcm", rcm);
|
|
needs_commit = true;
|
|
}
|
|
|
|
// Temp threshold
|
|
err = nvs_get_u8(nvs, "temp_threshold", &u8);
|
|
temp_threshold = (err == ESP_OK && u8 >= 40 && u8 <= 80) ? u8 : 60;
|
|
if (err != ESP_OK) {
|
|
nvs_set_u8(nvs, "temp_threshold", temp_threshold);
|
|
needs_commit = true;
|
|
}
|
|
|
|
// Optional limits
|
|
if (nvs_get_u32(nvs, "def_cons_lim", &u32) == ESP_OK)
|
|
evse_set_consumption_limit(u32);
|
|
|
|
if (nvs_get_u32(nvs, "def_ch_time_lim", &u32) == ESP_OK)
|
|
evse_set_charging_time_limit(u32);
|
|
|
|
if (nvs_get_u16(nvs, "def_un_pwr_lim", &u16) == ESP_OK)
|
|
evse_set_under_power_limit(u16);
|
|
|
|
// Save to NVS if needed
|
|
if (needs_commit) {
|
|
err = nvs_commit(nvs);
|
|
if (err == ESP_OK) {
|
|
ESP_LOGD(TAG, "Configuration committed to NVS.");
|
|
} else {
|
|
ESP_LOGE(TAG, "Failed to commit configuration to NVS: %s", esp_err_to_name(err));
|
|
}
|
|
}
|
|
}
|
|
|
|
// ========================
|
|
// Charging current getters/setters
|
|
// ========================
|
|
uint8_t evse_get_max_charging_current(void) {
|
|
return max_charging_current;
|
|
}
|
|
|
|
esp_err_t evse_set_max_charging_current(uint8_t value) {
|
|
if (value < MIN_CHARGING_CURRENT_LIMIT || value > MAX_CHARGING_CURRENT_LIMIT)
|
|
return ESP_ERR_INVALID_ARG;
|
|
max_charging_current = value;
|
|
nvs_set_u8(nvs, "max_chrg_curr", value);
|
|
return nvs_commit(nvs);
|
|
}
|
|
|
|
uint16_t evse_get_charging_current(void) {
|
|
return charging_current;
|
|
}
|
|
|
|
esp_err_t evse_set_charging_current(uint16_t value) {
|
|
if (value < (MIN_CHARGING_CURRENT_LIMIT * 10) || value > (max_charging_current * 10))
|
|
return ESP_ERR_INVALID_ARG;
|
|
charging_current = value;
|
|
nvs_set_u16(nvs, "def_chrg_curr", value);
|
|
return nvs_commit(nvs);
|
|
}
|
|
|
|
uint16_t evse_get_default_charging_current(void) {
|
|
uint16_t value;
|
|
if (nvs_get_u16(nvs, "def_chrg_curr", &value) == ESP_OK)
|
|
return value;
|
|
return charging_current;
|
|
}
|
|
|
|
esp_err_t evse_set_default_charging_current(uint16_t value) {
|
|
if (value < (MIN_CHARGING_CURRENT_LIMIT * 10) || value > (max_charging_current * 10))
|
|
return ESP_ERR_INVALID_ARG;
|
|
nvs_set_u16(nvs, "def_chrg_curr", value);
|
|
return nvs_commit(nvs);
|
|
}
|
|
|
|
// ========================
|
|
// Runtime current (not saved)
|
|
// ========================
|
|
void evse_set_runtime_charging_current(uint16_t value) {
|
|
if (value < (MIN_CHARGING_CURRENT_LIMIT) || value > (max_charging_current)) {
|
|
ESP_LOGW(TAG, "Rejected runtime charging current (out of bounds): %d", value);
|
|
return;
|
|
}
|
|
charging_current_runtime = value;
|
|
ESP_LOGD(TAG, "Runtime charging current updated: %d", charging_current_runtime);
|
|
}
|
|
|
|
uint16_t evse_get_runtime_charging_current(void) {
|
|
return charging_current_runtime;
|
|
}
|
|
|
|
|
|
// ========================
|
|
// Socket outlet
|
|
// ========================
|
|
bool evse_get_socket_outlet(void) {
|
|
return socket_outlet;
|
|
}
|
|
|
|
esp_err_t evse_set_socket_outlet(bool value) {
|
|
if (value && !board_config.proximity)
|
|
return ESP_ERR_INVALID_ARG;
|
|
socket_outlet = value;
|
|
nvs_set_u8(nvs, "socket_outlet", value);
|
|
return nvs_commit(nvs);
|
|
}
|
|
|
|
// ========================
|
|
// RCM
|
|
// ========================
|
|
bool evse_is_rcm(void) {
|
|
return rcm;
|
|
}
|
|
|
|
esp_err_t evse_set_rcm(bool value) {
|
|
if (value && !board_config.rcm)
|
|
return ESP_ERR_INVALID_ARG;
|
|
rcm = value;
|
|
nvs_set_u8(nvs, "rcm", value);
|
|
return nvs_commit(nvs);
|
|
}
|
|
|
|
// ========================
|
|
// Temperature
|
|
// ========================
|
|
uint8_t evse_get_temp_threshold(void) {
|
|
return temp_threshold;
|
|
}
|
|
|
|
esp_err_t evse_set_temp_threshold(uint8_t value) {
|
|
if (value < 40 || value > 80)
|
|
return ESP_ERR_INVALID_ARG;
|
|
temp_threshold = value;
|
|
nvs_set_u8(nvs, "temp_threshold", value);
|
|
return nvs_commit(nvs);
|
|
}
|
|
|
|
// ========================
|
|
// Authentication
|
|
// ========================
|
|
bool evse_is_require_auth(void) {
|
|
return require_auth;
|
|
}
|
|
|
|
void evse_set_require_auth(bool value) {
|
|
require_auth = value;
|
|
nvs_set_u8(nvs, "require_auth", value);
|
|
nvs_commit(nvs);
|
|
}
|
|
|
|
// ========================
|
|
// Availability
|
|
// ========================
|
|
static bool is_available = true;
|
|
|
|
bool evse_config_is_available(void) {
|
|
return is_available;
|
|
}
|
|
|
|
void evse_config_set_available(bool available) {
|
|
is_available = available;
|
|
}
|
|
|
|
// ========================
|
|
// Enable/Disable
|
|
// ========================
|
|
static bool is_enabled = true;
|
|
|
|
bool evse_config_is_enabled(void) {
|
|
return is_enabled;
|
|
}
|
|
|
|
void evse_config_set_enabled(bool enabled) {
|
|
is_enabled = enabled;
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_config.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_manager.c ===
|
|
#include "evse_manager.h"
|
|
#include "evse_state.h"
|
|
#include "evse_error.h"
|
|
#include "evse_hardware.h"
|
|
#include "evse_config.h"
|
|
#include "evse_api.h"
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/semphr.h"
|
|
#include "freertos/queue.h"
|
|
#include "esp_log.h"
|
|
#include <string.h>
|
|
|
|
#include "auth_events.h"
|
|
#include "loadbalancer_events.h"
|
|
#include "esp_event.h"
|
|
|
|
static const char *TAG = "EVSE_Manager";
|
|
|
|
static SemaphoreHandle_t evse_mutex;
|
|
static bool auth_enabled = false;
|
|
|
|
#define EVSE_MANAGER_TICK_PERIOD_MS 1000 // 1 segundo
|
|
|
|
// ===== Task de ciclo principal =====
|
|
static void evse_manager_task(void *arg) {
|
|
while (true) {
|
|
evse_manager_tick();
|
|
vTaskDelay(pdMS_TO_TICKS(EVSE_MANAGER_TICK_PERIOD_MS));
|
|
}
|
|
}
|
|
|
|
// ===== Tratador de eventos de autenticação =====
|
|
static void on_auth_event(void* arg, esp_event_base_t base, int32_t id, void* data) {
|
|
if (base != AUTH_EVENTS || data == NULL) return;
|
|
|
|
switch (id) {
|
|
case AUTH_EVENT_TAG_PROCESSED: {
|
|
auth_tag_event_data_t *evt = (auth_tag_event_data_t*)data;
|
|
ESP_LOGI("EVSE", "Tag: %s | Autorizada: %s", evt->tag, evt->authorized ? "SIM" : "NÃO");
|
|
evse_state_set_authorized(evt->authorized);
|
|
break;
|
|
}
|
|
|
|
case AUTH_EVENT_ENABLED_CHANGED:
|
|
case AUTH_EVENT_INIT: {
|
|
auth_enabled_event_data_t *evt = (auth_enabled_event_data_t*)data;
|
|
auth_enabled = evt->enabled;
|
|
|
|
ESP_LOGI("EVSE", "Auth %s (%s)",
|
|
id == AUTH_EVENT_ENABLED_CHANGED ? "ficou" : "init",
|
|
evt->enabled ? "ATIVO" : "INATIVO");
|
|
|
|
if (!auth_enabled) {
|
|
evse_state_set_authorized(true);
|
|
ESP_LOGI("EVSE", "Autenticação desativada → autorização forçada.");
|
|
} else {
|
|
evse_state_set_authorized(false);
|
|
ESP_LOGI("EVSE", "Autenticação ativada → aguardando autorização por tag.");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ===== Tratador de eventos de loadbalancer =====
|
|
static void on_loadbalancer_event(void* handler_arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data) {
|
|
if (event_id == LOADBALANCER_EVENT_INIT || event_id == LOADBALANCER_EVENT_STATE_CHANGED) {
|
|
const loadbalancer_state_event_t* evt = (const loadbalancer_state_event_t*) event_data;
|
|
ESP_LOGI(TAG, "Loadbalancer %s (ts: %lld)",
|
|
evt->enabled ? "ENABLED" : "DISABLED", evt->timestamp_us);
|
|
// Ações adicionais podem ser adicionadas aqui conforme necessário
|
|
} else if (event_id == LOADBALANCER_EVENT_CHARGING_LIMIT_CHANGED) {
|
|
const loadbalancer_charging_limit_event_t* evt = (const loadbalancer_charging_limit_event_t*) event_data;
|
|
ESP_LOGD(TAG, "Novo limite de corrente: %.1f A (ts: %lld)", evt->limit, evt->timestamp_us);
|
|
evse_set_runtime_charging_current((uint16_t)(evt->limit));
|
|
}
|
|
}
|
|
|
|
// ===== Inicialização =====
|
|
void evse_manager_init(void) {
|
|
evse_mutex = xSemaphoreCreateMutex();
|
|
|
|
evse_config_init();
|
|
evse_error_init();
|
|
evse_hardware_init();
|
|
evse_state_init();
|
|
|
|
ESP_ERROR_CHECK(esp_event_handler_register(AUTH_EVENTS, ESP_EVENT_ANY_ID, &on_auth_event, NULL));
|
|
ESP_ERROR_CHECK(esp_event_handler_register(LOADBALANCER_EVENTS, ESP_EVENT_ANY_ID, &on_loadbalancer_event, NULL));
|
|
|
|
ESP_LOGI(TAG, "EVSE Manager inicializado.");
|
|
xTaskCreate(evse_manager_task, "evse_manager_task", 4096, NULL, 5, NULL);
|
|
}
|
|
|
|
// ===== Main Tick =====
|
|
void evse_manager_tick(void) {
|
|
xSemaphoreTake(evse_mutex, portMAX_DELAY);
|
|
|
|
evse_hardware_tick();
|
|
evse_error_tick();
|
|
evse_state_tick();
|
|
evse_temperature_check();
|
|
|
|
if (auth_enabled) {
|
|
// If the car is disconnected, revoke authorization
|
|
if (evse_state_get_authorized() && evse_get_state() == EVSE_STATE_A) {
|
|
ESP_LOGI(TAG, "Vehicle disconnected → revoking authorization.");
|
|
evse_state_set_authorized(false);
|
|
}
|
|
} else {
|
|
// If authentication is disabled, ensure authorization is always granted
|
|
if (!evse_state_get_authorized()) {
|
|
evse_state_set_authorized(true);
|
|
ESP_LOGI(TAG, "Authentication disabled → forced authorization.");
|
|
}
|
|
}
|
|
|
|
xSemaphoreGive(evse_mutex);
|
|
}
|
|
|
|
|
|
// ===== API pública =====
|
|
bool evse_manager_is_available(void) {
|
|
return evse_config_is_available();
|
|
}
|
|
|
|
void evse_manager_set_available(bool available) {
|
|
evse_config_set_available(available);
|
|
}
|
|
|
|
void evse_manager_set_authorized(bool authorized) {
|
|
evse_state_set_authorized(authorized);
|
|
}
|
|
|
|
bool evse_manager_is_charging(void) {
|
|
return evse_state_is_charging(evse_get_state());
|
|
}
|
|
|
|
void evse_manager_set_enabled(bool enabled) {
|
|
evse_config_set_enabled(enabled);
|
|
}
|
|
|
|
bool evse_manager_is_enabled(void) {
|
|
return evse_config_is_enabled();
|
|
}
|
|
|
|
// === Fim de: components/evse/evse_manager.c ===
|
|
|
|
|
|
// === Início de: components/evse/evse_events.c ===
|
|
#include "evse_events.h"
|
|
|
|
ESP_EVENT_DEFINE_BASE(EVSE_EVENTS);
|
|
|
|
// === Fim de: components/evse/evse_events.c ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_pilot.h ===
|
|
#ifndef PILOT_H_
|
|
#define PILOT_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
|
|
/**
|
|
* @brief Níveis categóricos de tensão no sinal CP (Control Pilot)
|
|
*/
|
|
typedef enum
|
|
{
|
|
PILOT_VOLTAGE_12, ///< Estado A: +12V
|
|
PILOT_VOLTAGE_9, ///< Estado B: +9V
|
|
PILOT_VOLTAGE_6, ///< Estado C: +6V
|
|
PILOT_VOLTAGE_3, ///< Estado D: +3V
|
|
PILOT_VOLTAGE_1 ///< Estado E/F: abaixo de 3V
|
|
} pilot_voltage_t;
|
|
|
|
/**
|
|
* @brief Inicializa o driver do sinal Pilot
|
|
*/
|
|
void pilot_init(void);
|
|
|
|
/**
|
|
* @brief Define o nível do Pilot: +12V ou -12V
|
|
*
|
|
* @param level true = +12V, false = -12V
|
|
*/
|
|
void pilot_set_level(bool level);
|
|
|
|
/**
|
|
* @brief Ativa o PWM do Pilot com corrente limitada
|
|
*
|
|
* @param amps Corrente em décimos de ampère (ex: 160 = 16A)
|
|
*/
|
|
void pilot_set_amps(uint16_t amps);
|
|
|
|
/**
|
|
* @brief Mede o nível de tensão do Pilot e detecta -12V
|
|
*
|
|
* @param up_voltage Valor categórico da tensão positiva
|
|
* @param down_voltage_n12 true se o nível negativo atingir -12V
|
|
*/
|
|
void pilot_measure(pilot_voltage_t *up_voltage, bool *down_voltage_n12);
|
|
|
|
/**
|
|
* @brief Retorna o estado lógico atual do Pilot (nível alto = +12V)
|
|
*
|
|
* @return true se nível atual for +12V, false se for -12V
|
|
*/
|
|
bool pilot_get_state(void);
|
|
|
|
/**
|
|
* @brief Cache interno opcional dos níveis de tensão reais do Pilot
|
|
*/
|
|
typedef struct {
|
|
uint16_t high_mv; ///< Pico positivo medido (mV)
|
|
uint16_t low_mv; ///< Pico negativo medido (mV)
|
|
} pilot_voltage_cache_t;
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* PILOT_H_ */
|
|
|
|
// === Fim de: components/evse/include/evse_pilot.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_manager.h ===
|
|
#ifndef EVSE_MANAGER_H
|
|
#define EVSE_MANAGER_H
|
|
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/queue.h>
|
|
|
|
/**
|
|
* @brief Inicializa os módulos internos do EVSE (hardware, estado, erros, etc.)
|
|
* e inicia a tarefa de supervisão periódica (tick).
|
|
*/
|
|
void evse_manager_init(void);
|
|
|
|
/**
|
|
* @brief Executa uma iteração do ciclo de controle do EVSE.
|
|
*
|
|
* Esta função é chamada automaticamente pela task periódica,
|
|
* mas pode ser chamada manualmente em testes.
|
|
*/
|
|
void evse_manager_tick(void);
|
|
|
|
/**
|
|
* @brief Verifica se o EVSE está disponível para uso.
|
|
*
|
|
* Isso considera falhas críticas, disponibilidade configurada, etc.
|
|
*/
|
|
bool evse_manager_is_available(void);
|
|
|
|
/**
|
|
* @brief Define se o EVSE deve estar disponível (ex: via controle remoto).
|
|
*/
|
|
void evse_manager_set_available(bool available);
|
|
|
|
/**
|
|
* @brief Define se o EVSE está autorizado a carregar (ex: após autenticação).
|
|
*/
|
|
void evse_manager_set_authorized(bool authorized);
|
|
|
|
/**
|
|
* @brief Verifica se o EVSE está atualmente carregando.
|
|
*/
|
|
bool evse_manager_is_charging(void);
|
|
|
|
/**
|
|
* @brief Ativa ou desativa logicamente o EVSE (controla habilitação geral).
|
|
*/
|
|
void evse_manager_set_enabled(bool enabled);
|
|
|
|
/**
|
|
* @brief Verifica se o EVSE está ativado logicamente.
|
|
*/
|
|
bool evse_manager_is_enabled(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
#endif // EVSE_MANAGER_H
|
|
|
|
// === Fim de: components/evse/include/evse_manager.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_fsm.h ===
|
|
#ifndef EVSE_FSM_H
|
|
#define EVSE_FSM_H
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include "evse_api.h"
|
|
#include "evse_pilot.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @brief Reinicia a máquina de estados do EVSE para o estado inicial (A).
|
|
*/
|
|
void evse_fsm_reset(void);
|
|
|
|
/**
|
|
* @brief Processa uma leitura do sinal de piloto e atualiza a máquina de estados do EVSE.
|
|
*
|
|
* Esta função deve ser chamada periodicamente pelo núcleo de controle para
|
|
* avaliar mudanças no estado do conector, disponibilidade do carregador e
|
|
* autorização do usuário.
|
|
*
|
|
* @param pilot_voltage Leitura atual da tensão do sinal piloto.
|
|
* @param authorized Indica se o carregamento foi autorizado.
|
|
* @param available Indica se o carregador está disponível (ex: sem falhas).
|
|
* @param enabled Indica se o carregador está habilitado via software.
|
|
*/
|
|
void evse_fsm_process(pilot_voltage_t pilot_voltage, bool authorized, bool available, bool enabled);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // EVSE_FSM_H
|
|
|
|
// === Fim de: components/evse/include/evse_fsm.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_hardware.h ===
|
|
#ifndef EVSE_HARDWARE_H
|
|
#define EVSE_HARDWARE_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
|
|
/**
|
|
* @brief Inicializa todos os periféricos de hardware do EVSE (pilot, relé, trava, etc.)
|
|
*/
|
|
void evse_hardware_init(void);
|
|
|
|
/**
|
|
* @brief Executa atualizações periódicas no hardware (tick)
|
|
*/
|
|
void evse_hardware_tick(void);
|
|
|
|
/**
|
|
* @brief Verifica se o sinal piloto está em nível alto (12V)
|
|
*/
|
|
bool evse_hardware_is_pilot_high(void);
|
|
|
|
/**
|
|
* @brief Verifica se o veículo está fisicamente conectado via Proximity
|
|
*/
|
|
bool evse_hardware_is_vehicle_connected(void);
|
|
|
|
/**
|
|
* @brief Verifica se há consumo de energia (corrente detectada)
|
|
*/
|
|
bool evse_hardware_is_energy_detected(void);
|
|
|
|
/**
|
|
* @brief Liga o relé de fornecimento de energia
|
|
*/
|
|
void evse_hardware_relay_on(void);
|
|
|
|
/**
|
|
* @brief Desliga o relé de fornecimento de energia
|
|
*/
|
|
void evse_hardware_relay_off(void);
|
|
|
|
/**
|
|
* @brief Consulta o estado atual do relé
|
|
* @return true se ligado, false se desligado
|
|
*/
|
|
bool evse_hardware_relay_status(void);
|
|
|
|
/**
|
|
* @brief Aciona a trava física do conector
|
|
*/
|
|
void evse_hardware_lock(void);
|
|
|
|
/**
|
|
* @brief Libera a trava física do conector
|
|
*/
|
|
void evse_hardware_unlock(void);
|
|
|
|
/**
|
|
* @brief Verifica se o conector está travado
|
|
*/
|
|
bool evse_hardware_is_locked(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // EVSE_HARDWARE_H
|
|
|
|
// === Fim de: components/evse/include/evse_hardware.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_config.h ===
|
|
#ifndef EVSE_CONFIG_H
|
|
#define EVSE_CONFIG_H
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "esp_err.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// ========================
|
|
// Limites Globais (Defines)
|
|
// ========================
|
|
|
|
// Corrente máxima de carregamento (configurável pelo usuário)
|
|
#define MIN_CHARGING_CURRENT_LIMIT 6 // A
|
|
#define MAX_CHARGING_CURRENT_LIMIT 32 // A
|
|
|
|
// Corrente via cabo (proximity) — se configurável
|
|
#define MIN_CABLE_CURRENT_LIMIT 6 // A
|
|
#define MAX_CABLE_CURRENT_LIMIT 63 // A
|
|
|
|
// ========================
|
|
// Funções de Configuração
|
|
// ========================
|
|
|
|
// Inicialização
|
|
esp_err_t evse_config_init(void);
|
|
void evse_check_defaults(void);
|
|
|
|
// Corrente de carregamento
|
|
uint8_t evse_get_max_charging_current(void);
|
|
esp_err_t evse_set_max_charging_current(uint8_t value);
|
|
|
|
uint16_t evse_get_charging_current(void);
|
|
esp_err_t evse_set_charging_current(uint16_t value);
|
|
|
|
uint16_t evse_get_default_charging_current(void);
|
|
esp_err_t evse_set_default_charging_current(uint16_t value);
|
|
|
|
// Configuração de socket outlet
|
|
bool evse_get_socket_outlet(void);
|
|
esp_err_t evse_set_socket_outlet(bool socket_outlet);
|
|
|
|
void evse_set_runtime_charging_current(uint16_t value);
|
|
uint16_t evse_get_runtime_charging_current(void);
|
|
|
|
|
|
// RCM
|
|
bool evse_is_rcm(void);
|
|
esp_err_t evse_set_rcm(bool rcm);
|
|
|
|
// Temperatura
|
|
uint8_t evse_get_temp_threshold(void);
|
|
esp_err_t evse_set_temp_threshold(uint8_t threshold);
|
|
|
|
// Autenticação
|
|
bool evse_is_require_auth(void);
|
|
void evse_set_require_auth(bool require);
|
|
|
|
// Disponibilidade
|
|
bool evse_config_is_available(void);
|
|
void evse_config_set_available(bool available);
|
|
|
|
// Ativação/desativação do EVSE
|
|
bool evse_config_is_enabled(void);
|
|
void evse_config_set_enabled(bool enabled);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // EVSE_CONFIG_H
|
|
|
|
// === Fim de: components/evse/include/evse_config.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_state.h ===
|
|
#ifndef EVSE_STATE_H
|
|
#define EVSE_STATE_H
|
|
|
|
#include "evse_events.h"
|
|
|
|
|
|
#include <stdbool.h>
|
|
|
|
// Estado do EVSE (pilot signal)
|
|
typedef enum {
|
|
EVSE_STATE_A,
|
|
EVSE_STATE_B1,
|
|
EVSE_STATE_B2,
|
|
EVSE_STATE_C1,
|
|
EVSE_STATE_C2,
|
|
EVSE_STATE_D1,
|
|
EVSE_STATE_D2,
|
|
EVSE_STATE_E,
|
|
EVSE_STATE_F
|
|
} evse_state_t;
|
|
|
|
|
|
// Funções públicas necessárias
|
|
void evse_state_init(void);
|
|
void evse_state_tick(void);
|
|
|
|
void evse_state_set_authorized(bool authorized);
|
|
bool evse_state_get_authorized(void);
|
|
|
|
|
|
evse_state_t evse_get_state(void);
|
|
|
|
void evse_set_state(evse_state_t state);
|
|
|
|
// Converte o estado para string
|
|
const char* evse_state_to_str(evse_state_t state);
|
|
|
|
// Retorna true se o estado representa sessão ativa
|
|
bool evse_state_is_session(evse_state_t state);
|
|
|
|
// Retorna true se o estado representa carregamento ativo
|
|
bool evse_state_is_charging(evse_state_t state);
|
|
|
|
// Retorna true se o estado representa veículo conectado
|
|
bool evse_state_is_plugged(evse_state_t state);
|
|
|
|
//evse_state_event_t map_state_to_event(evse_state_t state);
|
|
|
|
#endif // EVSE_STATE_H
|
|
|
|
// === Fim de: components/evse/include/evse_state.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_error.h ===
|
|
#ifndef EVSE_ERROR_H
|
|
#define EVSE_ERROR_H
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include "evse_pilot.h"
|
|
|
|
|
|
#define EVSE_ERR_AUTO_CLEAR_BITS ( \
|
|
EVSE_ERR_DIODE_SHORT_BIT | \
|
|
EVSE_ERR_TEMPERATURE_HIGH_BIT | \
|
|
EVSE_ERR_RCM_TRIGGERED_BIT )
|
|
|
|
// Error bits
|
|
#define EVSE_ERR_DIODE_SHORT_BIT (1 << 0)
|
|
#define EVSE_ERR_LOCK_FAULT_BIT (1 << 1)
|
|
#define EVSE_ERR_UNLOCK_FAULT_BIT (1 << 2)
|
|
#define EVSE_ERR_RCM_SELFTEST_FAULT_BIT (1 << 3)
|
|
#define EVSE_ERR_RCM_TRIGGERED_BIT (1 << 4)
|
|
#define EVSE_ERR_TEMPERATURE_HIGH_BIT (1 << 5)
|
|
#define EVSE_ERR_PILOT_FAULT_BIT (1 << 6)
|
|
#define EVSE_ERR_TEMPERATURE_FAULT_BIT (1 << 7)
|
|
|
|
// Inicialização do módulo de erros
|
|
void evse_error_init(void);
|
|
|
|
// Verificações e monitoramento
|
|
void evse_error_check(pilot_voltage_t pilot_voltage, bool is_n12v);
|
|
|
|
void evse_temperature_check(void);
|
|
|
|
void evse_error_tick(void);
|
|
|
|
// Leitura e controle de erros
|
|
uint32_t evse_get_error(void);
|
|
bool evse_is_error_cleared(void);
|
|
void evse_mark_error_cleared(void);
|
|
void evse_error_set(uint32_t bitmask);
|
|
void evse_error_clear(uint32_t bitmask);
|
|
bool evse_error_is_active(void);
|
|
uint32_t evse_error_get_bits(void);
|
|
void evse_error_reset_flag(void);
|
|
bool evse_error_cleared_flag(void);
|
|
|
|
#endif // EVSE_ERROR_H
|
|
|
|
// === Fim de: components/evse/include/evse_error.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_limits.h ===
|
|
#ifndef EVSE_LIMITS_H
|
|
#define EVSE_LIMITS_H
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include "evse_state.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/// Estado dos limites
|
|
void evse_set_limit_reached(uint8_t value);
|
|
bool evse_is_limit_reached(void);
|
|
|
|
/// Verifica e aplica lógica de limites com base no estado atual do EVSE
|
|
void evse_limits_check(evse_state_t state);
|
|
|
|
/// Limites ativos (runtime)
|
|
uint32_t evse_get_consumption_limit(void);
|
|
void evse_set_consumption_limit(uint32_t value);
|
|
|
|
uint32_t evse_get_charging_time_limit(void);
|
|
void evse_set_charging_time_limit(uint32_t value);
|
|
|
|
uint16_t evse_get_under_power_limit(void);
|
|
void evse_set_under_power_limit(uint16_t value);
|
|
|
|
/// Limites padrão (persistentes)
|
|
uint32_t evse_get_default_consumption_limit(void);
|
|
void evse_set_default_consumption_limit(uint32_t value);
|
|
|
|
uint32_t evse_get_default_charging_time_limit(void);
|
|
void evse_set_default_charging_time_limit(uint32_t value);
|
|
|
|
uint16_t evse_get_default_under_power_limit(void);
|
|
void evse_set_default_under_power_limit(uint16_t value);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // EVSE_LIMITS_H
|
|
|
|
// === Fim de: components/evse/include/evse_limits.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_events.h ===
|
|
#ifndef EVSE_EVENTS_H
|
|
#define EVSE_EVENTS_H
|
|
|
|
#pragma once
|
|
#include "esp_event.h"
|
|
|
|
ESP_EVENT_DECLARE_BASE(EVSE_EVENTS);
|
|
|
|
typedef enum {
|
|
EVSE_EVENT_INIT,
|
|
EVSE_EVENT_STATE_CHANGED,
|
|
// Outros eventos possíveis futuramente
|
|
} evse_event_id_t;
|
|
|
|
typedef enum {
|
|
EVSE_STATE_EVENT_IDLE,
|
|
EVSE_STATE_EVENT_WAITING,
|
|
EVSE_STATE_EVENT_CHARGING,
|
|
EVSE_STATE_EVENT_FAULT
|
|
} evse_state_event_t;
|
|
|
|
typedef struct {
|
|
evse_state_event_t state;
|
|
} evse_state_event_data_t;
|
|
|
|
|
|
#endif // EVSE_EVENTS_H
|
|
|
|
// === Fim de: components/evse/include/evse_events.h ===
|
|
|
|
|
|
// === Início de: components/evse/include/evse_api.h ===
|
|
#ifndef EVSE_API_H
|
|
#define EVSE_API_H
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include "esp_err.h"
|
|
#include "evse_state.h" // Define evse_state_t
|
|
|
|
// Inicialização
|
|
void evse_init(void);
|
|
void evse_process(void);
|
|
|
|
// Estado
|
|
evse_state_t evse_get_state(void);
|
|
const char* evse_state_to_str(evse_state_t state);
|
|
bool evse_is_connector_plugged(evse_state_t state);
|
|
bool evse_is_limit_reached(void);
|
|
|
|
// Autorização e disponibilidade
|
|
bool evse_is_enabled(void);
|
|
void evse_set_enabled(bool value);
|
|
bool evse_is_available(void);
|
|
void evse_set_available(bool value);
|
|
bool evse_is_require_auth(void);
|
|
void evse_set_require_auth(bool value);
|
|
|
|
// Corrente
|
|
uint16_t evse_get_charging_current(void);
|
|
esp_err_t evse_set_charging_current(uint16_t value);
|
|
uint16_t evse_get_default_charging_current(void);
|
|
esp_err_t evse_set_default_charging_current(uint16_t value);
|
|
uint8_t evse_get_max_charging_current(void);
|
|
esp_err_t evse_set_max_charging_current(uint8_t value);
|
|
|
|
// Temperatura
|
|
uint8_t evse_get_temp_threshold(void);
|
|
esp_err_t evse_set_temp_threshold(uint8_t value);
|
|
|
|
// RCM / Socket
|
|
bool evse_get_socket_outlet(void);
|
|
esp_err_t evse_set_socket_outlet(bool value);
|
|
bool evse_is_rcm(void);
|
|
esp_err_t evse_set_rcm(bool value);
|
|
|
|
// Limites
|
|
uint32_t evse_get_consumption_limit(void);
|
|
void evse_set_consumption_limit(uint32_t value);
|
|
uint32_t evse_get_charging_time_limit(void);
|
|
void evse_set_charging_time_limit(uint32_t value);
|
|
uint16_t evse_get_under_power_limit(void);
|
|
void evse_set_under_power_limit(uint16_t value);
|
|
|
|
void evse_set_limit_reached(uint8_t value);
|
|
|
|
// Limites default
|
|
uint32_t evse_get_default_consumption_limit(void);
|
|
void evse_set_default_consumption_limit(uint32_t value);
|
|
uint32_t evse_get_default_charging_time_limit(void);
|
|
void evse_set_default_charging_time_limit(uint32_t value);
|
|
uint16_t evse_get_default_under_power_limit(void);
|
|
void evse_set_default_under_power_limit(uint16_t value);
|
|
|
|
#endif // EVSE_API_H
|
|
|
|
// === Fim de: components/evse/include/evse_api.h ===
|
|
|
|
|
|
// === Início de: components/loadbalancer/src/loadbalancer_events.c ===
|
|
#include "loadbalancer_events.h"
|
|
|
|
// Define a base de eventos para o loadbalancer
|
|
ESP_EVENT_DEFINE_BASE(LOADBALANCER_EVENTS);
|
|
|
|
// === Fim de: components/loadbalancer/src/loadbalancer_events.c ===
|
|
|
|
|
|
// === Início de: components/loadbalancer/src/loadbalancer.c ===
|
|
#include "loadbalancer.h"
|
|
#include "loadbalancer_events.h"
|
|
#include "esp_event.h"
|
|
#include "esp_log.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "input_filter.h"
|
|
#include "nvs_flash.h"
|
|
#include "nvs.h"
|
|
#include <string.h>
|
|
#include "meter_events.h"
|
|
#include "evse_events.h"
|
|
|
|
|
|
|
|
static const char *TAG = "loadbalancer";
|
|
|
|
// Limites configuráveis
|
|
#define MIN_CHARGING_CURRENT_LIMIT 6 // A
|
|
#define MAX_CHARGING_CURRENT_LIMIT 32 // A
|
|
#define MIN_GRID_CURRENT_LIMIT 6 // A
|
|
#define MAX_GRID_CURRENT_LIMIT 100 // A
|
|
|
|
// Parâmetros
|
|
static uint8_t max_grid_current = MAX_GRID_CURRENT_LIMIT;
|
|
static bool loadbalancer_enabled = false;
|
|
|
|
static float grid_current = 0.0f;
|
|
static float evse_current = 0.0f;
|
|
static input_filter_t grid_filter;
|
|
static input_filter_t evse_filter;
|
|
|
|
#define NVS_NAMESPACE "loadbalancing"
|
|
#define NVS_MAX_GRID_CURRENT "max_grid_curr"
|
|
#define NVS_LOADBALANCER_ENABLED "enabled"
|
|
|
|
static void loadbalancer_meter_event_handler(void *handler_arg,
|
|
esp_event_base_t base,
|
|
int32_t id,
|
|
void *event_data)
|
|
{
|
|
if (id != METER_EVENT_DATA_READY || event_data == NULL)
|
|
return;
|
|
|
|
const meter_event_data_t *evt = (const meter_event_data_t *)event_data;
|
|
|
|
ESP_LOGI(TAG, "Received meter event from source: %s", evt->source);
|
|
ESP_LOGI(TAG, "Raw IRMS: [%.2f, %.2f, %.2f] A", evt->irms[0], evt->irms[1], evt->irms[2]);
|
|
ESP_LOGI(TAG, "Raw VRMS: [%.1f, %.1f, %.1f] V", evt->vrms[0], evt->vrms[1], evt->vrms[2]);
|
|
ESP_LOGI(TAG, "Raw Power: [W1=%d, W2=%d, W3=%d]", evt->watt[0], evt->watt[1], evt->watt[2]);
|
|
ESP_LOGI(TAG, "Freq: %.2f Hz | PF: %.2f | Energy: %.3f kWh",
|
|
evt->frequency, evt->power_factor, evt->total_energy);
|
|
|
|
// Calcula a corrente máxima entre as 3 fases
|
|
float max_irms = evt->irms[0];
|
|
for (int i = 1; i < 3; ++i)
|
|
{
|
|
if (evt->irms[i] > max_irms)
|
|
{
|
|
max_irms = evt->irms[i];
|
|
}
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Max IRMS detected: %.2f A", max_irms);
|
|
|
|
// Atualiza com filtro exponencial dependendo da origem
|
|
if (strncmp(evt->source, "GRID", 4) == 0)
|
|
{
|
|
grid_current = input_filter_update(&grid_filter, max_irms);
|
|
ESP_LOGI(TAG, "GRID IRMS (filtered): %.2f A", grid_current);
|
|
}
|
|
else if (strncmp(evt->source, "EVSE", 4) == 0)
|
|
{
|
|
evse_current = input_filter_update(&evse_filter, max_irms);
|
|
ESP_LOGI(TAG, "EVSE IRMS (filtered): %.2f A", evse_current);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGW(TAG, "Unknown meter event source: %s", evt->source);
|
|
}
|
|
}
|
|
|
|
static void loadbalancer_evse_event_handler(void *handler_arg,
|
|
esp_event_base_t base,
|
|
int32_t id,
|
|
void *event_data)
|
|
{
|
|
const evse_state_event_data_t *evt = (const evse_state_event_data_t *)event_data;
|
|
|
|
ESP_LOGI(TAG, "EVSE state changed: %d", evt->state);
|
|
|
|
switch (evt->state)
|
|
{
|
|
case EVSE_STATE_EVENT_IDLE:
|
|
// Vehicle is disconnected - current flow can be reduced or reset
|
|
ESP_LOGI(TAG, "EVSE is IDLE - possible to release current");
|
|
break;
|
|
|
|
case EVSE_STATE_EVENT_WAITING:
|
|
// EV is connected but not charging yet (e.g., waiting for authorization)
|
|
ESP_LOGI(TAG, "EVSE is waiting - connected but not charging");
|
|
break;
|
|
|
|
case EVSE_STATE_EVENT_CHARGING:
|
|
grid_current = 0.0f;
|
|
evse_current = 0.0f;
|
|
// Charging has started - maintain or monitor current usage
|
|
ESP_LOGI(TAG, "EVSE is charging");
|
|
break;
|
|
|
|
case EVSE_STATE_EVENT_FAULT:
|
|
// A fault has occurred - safety measures may be needed
|
|
ESP_LOGW(TAG, "EVSE is in FAULT - temporarily disabling load balancing");
|
|
// Optional: disable load balancing during fault condition
|
|
// loadbalancer_set_enabled(false);
|
|
break;
|
|
|
|
default:
|
|
ESP_LOGW(TAG, "Unknown EVSE state: %d", evt->state);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Carrega configuração do NVS
|
|
static esp_err_t loadbalancer_load_config()
|
|
{
|
|
nvs_handle_t handle;
|
|
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to open NVS for load/init: %s", esp_err_to_name(err));
|
|
return err;
|
|
}
|
|
|
|
bool needs_commit = false;
|
|
uint8_t temp_u8;
|
|
|
|
// max_grid_current
|
|
err = nvs_get_u8(handle, NVS_MAX_GRID_CURRENT, &temp_u8);
|
|
if (err == ESP_OK && temp_u8 >= MIN_GRID_CURRENT_LIMIT && temp_u8 <= MAX_GRID_CURRENT_LIMIT)
|
|
{
|
|
max_grid_current = temp_u8;
|
|
}
|
|
else
|
|
{
|
|
max_grid_current = MAX_GRID_CURRENT_LIMIT;
|
|
nvs_set_u8(handle, NVS_MAX_GRID_CURRENT, max_grid_current);
|
|
ESP_LOGW(TAG, "max_grid_current missing or invalid, setting default: %d", max_grid_current);
|
|
needs_commit = true;
|
|
}
|
|
|
|
// loadbalancer_enabled
|
|
err = nvs_get_u8(handle, NVS_LOADBALANCER_ENABLED, &temp_u8);
|
|
if (err == ESP_OK && temp_u8 <= 1)
|
|
{
|
|
loadbalancer_enabled = (temp_u8 != 0);
|
|
}
|
|
else
|
|
{
|
|
loadbalancer_enabled = false;
|
|
nvs_set_u8(handle, NVS_LOADBALANCER_ENABLED, 0);
|
|
ESP_LOGW(TAG, "loadbalancer_enabled missing or invalid, setting default: 0");
|
|
needs_commit = true;
|
|
}
|
|
|
|
if (needs_commit)
|
|
{
|
|
nvs_commit(handle);
|
|
}
|
|
|
|
nvs_close(handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
// Salva o estado habilitado no NVS
|
|
void loadbalancer_set_enabled(bool enabled)
|
|
{
|
|
ESP_LOGI(TAG, "Setting load balancing enabled to %d", enabled);
|
|
nvs_handle_t handle;
|
|
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to open NVS: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
err = nvs_set_u8(handle, NVS_LOADBALANCER_ENABLED, enabled ? 1 : 0);
|
|
if (err == ESP_OK)
|
|
{
|
|
nvs_commit(handle);
|
|
loadbalancer_enabled = enabled;
|
|
ESP_LOGI(TAG, "Load balancing enabled state saved");
|
|
|
|
loadbalancer_state_event_t evt = {
|
|
.enabled = enabled,
|
|
.timestamp_us = esp_timer_get_time()};
|
|
|
|
esp_event_post(LOADBALANCER_EVENTS,
|
|
LOADBALANCER_EVENT_STATE_CHANGED,
|
|
&evt,
|
|
sizeof(evt),
|
|
portMAX_DELAY);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "Failed to save loadbalancer_enabled");
|
|
}
|
|
|
|
nvs_close(handle);
|
|
}
|
|
|
|
// Define e salva o limite de corrente da rede
|
|
esp_err_t load_balancing_set_max_grid_current(uint8_t value)
|
|
{
|
|
if (value < MIN_GRID_CURRENT_LIMIT || value > MAX_GRID_CURRENT_LIMIT)
|
|
{
|
|
ESP_LOGE(TAG, "Invalid grid current limit: %d", value);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
nvs_handle_t handle;
|
|
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to open NVS: %s", esp_err_to_name(err));
|
|
return err;
|
|
}
|
|
|
|
err = nvs_set_u8(handle, NVS_MAX_GRID_CURRENT, value);
|
|
if (err == ESP_OK)
|
|
{
|
|
nvs_commit(handle);
|
|
max_grid_current = value;
|
|
ESP_LOGI(TAG, "max_grid_current set to: %d", value);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "Failed to save max_grid_current to NVS");
|
|
}
|
|
|
|
nvs_close(handle);
|
|
return err;
|
|
}
|
|
|
|
uint8_t load_balancing_get_max_grid_current(void)
|
|
{
|
|
return max_grid_current;
|
|
}
|
|
|
|
bool loadbalancer_is_enabled(void)
|
|
{
|
|
return loadbalancer_enabled;
|
|
}
|
|
|
|
// Tarefa principal com eventos
|
|
void loadbalancer_task(void *param)
|
|
{
|
|
while (true)
|
|
{
|
|
if (!loadbalancer_enabled)
|
|
{
|
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
|
continue;
|
|
}
|
|
|
|
float available = max_grid_current - grid_current + evse_current;
|
|
|
|
if (available < MIN_CHARGING_CURRENT_LIMIT)
|
|
{
|
|
available = MIN_CHARGING_CURRENT_LIMIT;
|
|
}
|
|
else if (available > max_grid_current)
|
|
{
|
|
available = max_grid_current;
|
|
}
|
|
|
|
ESP_LOGD(TAG, "Setting EVSE current limit: %.1f A", available);
|
|
|
|
loadbalancer_charging_limit_event_t evt = {
|
|
.limit = available,
|
|
.timestamp_us = esp_timer_get_time()};
|
|
|
|
esp_event_post(LOADBALANCER_EVENTS,
|
|
LOADBALANCER_EVENT_CHARGING_LIMIT_CHANGED,
|
|
&evt,
|
|
sizeof(evt),
|
|
portMAX_DELAY);
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
|
}
|
|
}
|
|
|
|
void loadbalancer_init(void)
|
|
{
|
|
ESP_LOGI(TAG, "Initializing load balancer");
|
|
|
|
if (loadbalancer_load_config() != ESP_OK)
|
|
{
|
|
ESP_LOGW(TAG, "Failed to load/init config. Using in-memory defaults.");
|
|
}
|
|
|
|
input_filter_init(&grid_filter, 0.3f);
|
|
input_filter_init(&evse_filter, 0.3f);
|
|
|
|
if (xTaskCreate(loadbalancer_task, "loadbalancer", 4096, NULL, 4, NULL) != pdPASS)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to create loadbalancer task");
|
|
}
|
|
|
|
loadbalancer_state_event_t evt = {
|
|
.enabled = loadbalancer_enabled,
|
|
.timestamp_us = esp_timer_get_time()};
|
|
|
|
esp_event_post(LOADBALANCER_EVENTS,
|
|
LOADBALANCER_EVENT_INIT,
|
|
&evt,
|
|
sizeof(evt),
|
|
portMAX_DELAY);
|
|
|
|
ESP_ERROR_CHECK(esp_event_handler_register(METER_EVENT, METER_EVENT_DATA_READY,
|
|
&loadbalancer_meter_event_handler, NULL));
|
|
|
|
ESP_ERROR_CHECK(esp_event_handler_register(EVSE_EVENTS,
|
|
EVSE_EVENT_STATE_CHANGED,
|
|
&loadbalancer_evse_event_handler,
|
|
NULL));
|
|
}
|
|
|
|
// === Fim de: components/loadbalancer/src/loadbalancer.c ===
|
|
|
|
|
|
// === Início de: components/loadbalancer/src/input_filter.c ===
|
|
#include "input_filter.h"
|
|
|
|
void input_filter_init(input_filter_t *filter, float alpha) {
|
|
if (filter) {
|
|
filter->alpha = alpha;
|
|
filter->value = 0.0f;
|
|
filter->initialized = 0;
|
|
}
|
|
}
|
|
|
|
float input_filter_update(input_filter_t *filter, float input) {
|
|
if (!filter) return input;
|
|
|
|
if (!filter->initialized) {
|
|
filter->value = input;
|
|
filter->initialized = 1;
|
|
} else {
|
|
filter->value = filter->alpha * input + (1.0f - filter->alpha) * filter->value;
|
|
}
|
|
|
|
return filter->value;
|
|
}
|
|
|
|
// === Fim de: components/loadbalancer/src/input_filter.c ===
|
|
|
|
|
|
// === Início de: components/loadbalancer/include/loadbalancer_events.h ===
|
|
#pragma once
|
|
#include "esp_event.h"
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "esp_timer.h"
|
|
|
|
ESP_EVENT_DECLARE_BASE(LOADBALANCER_EVENTS);
|
|
|
|
typedef enum {
|
|
LOADBALANCER_EVENT_INIT,
|
|
LOADBALANCER_EVENT_STATE_CHANGED,
|
|
LOADBALANCER_EVENT_CHARGING_LIMIT_CHANGED
|
|
} loadbalancer_event_id_t;
|
|
|
|
typedef struct {
|
|
float limit;
|
|
int64_t timestamp_us;
|
|
} loadbalancer_charging_limit_event_t;
|
|
|
|
typedef struct {
|
|
bool enabled;
|
|
int64_t timestamp_us;
|
|
} loadbalancer_state_event_t;
|
|
|
|
|
|
// === Fim de: components/loadbalancer/include/loadbalancer_events.h ===
|
|
|
|
|
|
// === Início de: components/loadbalancer/include/loadbalancer.h ===
|
|
#ifndef LOADBALANCER_H_
|
|
#define LOADBALANCER_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "esp_err.h"
|
|
|
|
|
|
/**
|
|
* @brief Initializes the load balancer.
|
|
*
|
|
* This function configures the load balancer and its resources, including
|
|
* any necessary persistence configurations, such as storage in NVS (Non-Volatile Storage).
|
|
* This function prepares the system to perform load balancing efficiently.
|
|
*/
|
|
void loadbalancer_init(void);
|
|
|
|
/**
|
|
* @brief Continuous task for the load balancer.
|
|
*
|
|
* This function executes the load balancing logic continuously, typically in a FreeRTOS task.
|
|
* It performs balance calculations, checks the grid current and energy conditions, and adjusts
|
|
* the outputs as necessary to ensure efficient energy consumption.
|
|
*
|
|
* @param param Input parameter, usually used to pass additional information or relevant context
|
|
* for the task execution.
|
|
*/
|
|
void loadbalancer_task(void *param);
|
|
|
|
/**
|
|
* @brief Enables or disables the load balancing system.
|
|
*
|
|
* This function allows enabling or disabling the load balancing system. When enabled, the load
|
|
* balancer starts managing the grid current based on the configured limits. If disabled, the system
|
|
* operates without balancing.
|
|
*
|
|
* The configuration is persisted in NVS, ensuring that the choice is maintained across system restarts.
|
|
*
|
|
* @param value If true, enables load balancing. If false, disables it.
|
|
*/
|
|
void loadbalancer_set_enabled(bool value);
|
|
|
|
/**
|
|
* @brief Checks if load balancing is enabled.
|
|
*
|
|
* This function returns the current status of the load balancing system.
|
|
*
|
|
* @return Returns true if load balancing is enabled, otherwise returns false.
|
|
*/
|
|
bool loadbalancer_is_enabled(void);
|
|
|
|
/**
|
|
* @brief Sets the maximum grid current.
|
|
*
|
|
* This function configures the maximum grid current that can be supplied to the load balancing system.
|
|
* The value set ensures that the system does not overload the electrical infrastructure and respects
|
|
* the safety limits.
|
|
*
|
|
* @param max_grid_current The maximum allowed current (in amperes) for the load balancing system.
|
|
* This value should be appropriate for the grid capacity and the installation.
|
|
*/
|
|
esp_err_t load_balancing_set_max_grid_current(uint8_t max_grid_current);
|
|
|
|
|
|
/**
|
|
* @brief Gets the maximum grid current.
|
|
*
|
|
* This function retrieves the current maximum grid current limit.
|
|
*
|
|
* @return The maximum grid current (in amperes).
|
|
*/
|
|
uint8_t load_balancing_get_max_grid_current(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* LOADBALANCER_H_ */
|
|
|
|
// === Fim de: components/loadbalancer/include/loadbalancer.h ===
|
|
|
|
|
|
// === Início de: components/loadbalancer/include/input_filter.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef struct {
|
|
float alpha; ///< Fator de suavização (0.0 a 1.0)
|
|
float value; ///< Último valor filtrado
|
|
int initialized; ///< Flag de inicialização
|
|
} input_filter_t;
|
|
|
|
/**
|
|
* @brief Inicializa o filtro com o fator alpha desejado.
|
|
* @param filter Ponteiro para a estrutura do filtro
|
|
* @param alpha Valor entre 0.0 (mais lento) e 1.0 (sem filtro)
|
|
*/
|
|
void input_filter_init(input_filter_t *filter, float alpha);
|
|
|
|
/**
|
|
* @brief Atualiza o valor filtrado com uma nova entrada.
|
|
* @param filter Ponteiro para o filtro
|
|
* @param input Valor bruto
|
|
* @return Valor suavizado
|
|
*/
|
|
float input_filter_update(input_filter_t *filter, float input);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/loadbalancer/include/input_filter.h ===
|
|
|
|
|
|
// === Início de: components/auth/src/auth_events.c ===
|
|
#include "auth_events.h"
|
|
|
|
ESP_EVENT_DEFINE_BASE(AUTH_EVENTS);
|
|
|
|
// === Fim de: components/auth/src/auth_events.c ===
|
|
|
|
|
|
// === Início de: components/auth/src/wiegand.c ===
|
|
/**
|
|
* @file wiegand.c
|
|
*
|
|
* ESP-IDF Wiegand protocol receiver
|
|
*/
|
|
#include <esp_log.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <esp_idf_lib_helpers.h>
|
|
#include "wiegand.h"
|
|
|
|
static const char *TAG = "wiegand";
|
|
|
|
#define TIMER_INTERVAL_US 50000 // 50ms
|
|
|
|
#define CHECK(x) \
|
|
do \
|
|
{ \
|
|
esp_err_t __; \
|
|
if ((__ = x) != ESP_OK) \
|
|
return __; \
|
|
} while (0)
|
|
#define CHECK_ARG(VAL) \
|
|
do \
|
|
{ \
|
|
if (!(VAL)) \
|
|
return ESP_ERR_INVALID_ARG; \
|
|
} while (0)
|
|
|
|
static void isr_disable(wiegand_reader_t *reader)
|
|
{
|
|
gpio_set_intr_type(reader->gpio_d0, GPIO_INTR_DISABLE);
|
|
gpio_set_intr_type(reader->gpio_d1, GPIO_INTR_DISABLE);
|
|
}
|
|
|
|
static void isr_enable(wiegand_reader_t *reader)
|
|
{
|
|
gpio_set_intr_type(reader->gpio_d0, GPIO_INTR_NEGEDGE);
|
|
gpio_set_intr_type(reader->gpio_d1, GPIO_INTR_NEGEDGE);
|
|
}
|
|
|
|
#if HELPER_TARGET_IS_ESP32
|
|
static void IRAM_ATTR isr_handler(void *arg)
|
|
#else
|
|
static void isr_handler(void *arg)
|
|
#endif
|
|
{
|
|
wiegand_reader_t *reader = (wiegand_reader_t *)arg;
|
|
if (!reader->enabled)
|
|
return;
|
|
|
|
int d0 = gpio_get_level(reader->gpio_d0);
|
|
int d1 = gpio_get_level(reader->gpio_d1);
|
|
|
|
// ignore equal
|
|
if (d0 == d1)
|
|
return;
|
|
// overflow
|
|
if (reader->bits >= reader->size * 8)
|
|
return;
|
|
|
|
esp_timer_stop(reader->timer);
|
|
|
|
uint8_t value;
|
|
if (reader->bit_order == WIEGAND_MSB_FIRST)
|
|
value = (d0 ? 0x80 : 0) >> (reader->bits % 8);
|
|
else
|
|
value = (d0 ? 1 : 0) << (reader->bits % 8);
|
|
|
|
if (reader->byte_order == WIEGAND_MSB_FIRST)
|
|
reader->buf[reader->size - reader->bits / 8 - 1] |= value;
|
|
else
|
|
reader->buf[reader->bits / 8] |= value;
|
|
|
|
reader->bits++;
|
|
|
|
esp_timer_start_once(reader->timer, TIMER_INTERVAL_US);
|
|
}
|
|
|
|
static void timer_handler(void *arg)
|
|
{
|
|
wiegand_reader_t *reader = (wiegand_reader_t *)arg;
|
|
|
|
ESP_LOGI(TAG, "Got %d bits of data", reader->bits);
|
|
|
|
wiegand_reader_disable(reader);
|
|
|
|
if (reader->callback)
|
|
reader->callback(reader);
|
|
|
|
wiegand_reader_enable(reader);
|
|
|
|
isr_enable(reader);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
esp_err_t wiegand_reader_init(wiegand_reader_t *reader, gpio_num_t gpio_d0, gpio_num_t gpio_d1,
|
|
bool internal_pullups, size_t buf_size, wiegand_callback_t callback, wiegand_order_t bit_order,
|
|
wiegand_order_t byte_order)
|
|
{
|
|
CHECK_ARG(reader && buf_size && callback);
|
|
|
|
/*
|
|
esp_err_t res = gpio_install_isr_service(0);
|
|
if (res != ESP_OK && res != ESP_ERR_INVALID_STATE)
|
|
return res;
|
|
*/
|
|
|
|
memset(reader, 0, sizeof(wiegand_reader_t));
|
|
reader->gpio_d0 = gpio_d0;
|
|
reader->gpio_d1 = gpio_d1;
|
|
reader->size = buf_size;
|
|
reader->buf = calloc(buf_size, 1);
|
|
reader->bit_order = bit_order;
|
|
reader->byte_order = byte_order;
|
|
reader->callback = callback;
|
|
|
|
esp_timer_create_args_t timer_args = {
|
|
.name = TAG,
|
|
.arg = reader,
|
|
.callback = timer_handler,
|
|
.dispatch_method = ESP_TIMER_TASK};
|
|
CHECK(esp_timer_create(&timer_args, &reader->timer));
|
|
|
|
CHECK(gpio_set_direction(gpio_d0, GPIO_MODE_INPUT));
|
|
CHECK(gpio_set_direction(gpio_d1, GPIO_MODE_INPUT));
|
|
CHECK(gpio_set_pull_mode(gpio_d0, internal_pullups ? GPIO_PULLUP_ONLY : GPIO_FLOATING));
|
|
CHECK(gpio_set_pull_mode(gpio_d1, internal_pullups ? GPIO_PULLUP_ONLY : GPIO_FLOATING));
|
|
isr_disable(reader);
|
|
CHECK(gpio_isr_handler_add(gpio_d0, isr_handler, reader));
|
|
CHECK(gpio_isr_handler_add(gpio_d1, isr_handler, reader));
|
|
isr_enable(reader);
|
|
reader->enabled = true;
|
|
|
|
ESP_LOGI(TAG, "Reader initialized on D0=%d, D1=%d", gpio_d0, gpio_d1);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t wiegand_reader_disable(wiegand_reader_t *reader)
|
|
{
|
|
CHECK_ARG(reader);
|
|
|
|
isr_disable(reader);
|
|
esp_timer_stop(reader->timer);
|
|
reader->enabled = false;
|
|
|
|
ESP_LOGI(TAG, "Reader on D0=%d, D1=%d disabled", reader->gpio_d0, reader->gpio_d1);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t wiegand_reader_enable(wiegand_reader_t *reader)
|
|
{
|
|
CHECK_ARG(reader);
|
|
|
|
reader->bits = 0;
|
|
memset(reader->buf, 0, reader->size);
|
|
|
|
isr_enable(reader);
|
|
reader->enabled = true;
|
|
|
|
ESP_LOGI(TAG, "Reader on D0=%d, D1=%d enabled", reader->gpio_d0, reader->gpio_d1);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t wiegand_reader_done(wiegand_reader_t *reader)
|
|
{
|
|
CHECK_ARG(reader && reader->buf);
|
|
|
|
isr_disable(reader);
|
|
CHECK(gpio_isr_handler_remove(reader->gpio_d0));
|
|
CHECK(gpio_isr_handler_remove(reader->gpio_d1));
|
|
esp_timer_stop(reader->timer);
|
|
CHECK(esp_timer_delete(reader->timer));
|
|
free(reader->buf);
|
|
|
|
ESP_LOGI(TAG, "Reader removed");
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
// === Fim de: components/auth/src/wiegand.c ===
|
|
|
|
|
|
// === Início de: components/auth/src/auth.c ===
|
|
/*
|
|
* auth.c
|
|
*/
|
|
|
|
#include "auth.h"
|
|
#include "auth_events.h"
|
|
#include "esp_event.h"
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#include <freertos/queue.h>
|
|
#include <esp_log.h>
|
|
#include <string.h>
|
|
#include "wiegand_reader.h"
|
|
#include "nvs_flash.h"
|
|
#include "nvs.h"
|
|
|
|
#define MAX_TAGS 50
|
|
|
|
static const char *TAG = "Auth";
|
|
|
|
static bool enabled = false;
|
|
static char valid_tags[MAX_TAGS][AUTH_TAG_MAX_LEN];
|
|
static int tag_count = 0;
|
|
|
|
// ===========================
|
|
// Persistência em NVS
|
|
// ===========================
|
|
|
|
static void load_auth_config(void) {
|
|
nvs_handle_t handle;
|
|
esp_err_t err = nvs_open("auth", NVS_READONLY, &handle);
|
|
if (err == ESP_OK) {
|
|
uint8_t val;
|
|
if (nvs_get_u8(handle, "enabled", &val) == ESP_OK) {
|
|
enabled = val;
|
|
ESP_LOGI(TAG, "Loaded auth enabled = %d", enabled);
|
|
}
|
|
nvs_close(handle);
|
|
} else {
|
|
ESP_LOGW(TAG, "No stored auth config found. Using default.");
|
|
}
|
|
}
|
|
|
|
static void save_auth_config(void) {
|
|
nvs_handle_t handle;
|
|
if (nvs_open("auth", NVS_READWRITE, &handle) == ESP_OK) {
|
|
nvs_set_u8(handle, "enabled", enabled);
|
|
nvs_commit(handle);
|
|
nvs_close(handle);
|
|
ESP_LOGI(TAG, "Auth config saved: enabled = %d", enabled);
|
|
} else {
|
|
ESP_LOGE(TAG, "Failed to save auth config.");
|
|
}
|
|
}
|
|
|
|
// ===========================
|
|
// Internos
|
|
// ===========================
|
|
|
|
static bool is_tag_valid(const char *tag) {
|
|
for (int i = 0; i < tag_count; i++) {
|
|
if (strncmp(valid_tags[i], tag, AUTH_TAG_MAX_LEN) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return true;
|
|
//TODO
|
|
//return false;
|
|
}
|
|
|
|
// ===========================
|
|
// API pública
|
|
// ===========================
|
|
|
|
void auth_set_enabled(bool value) {
|
|
enabled = value;
|
|
save_auth_config();
|
|
ESP_LOGI(TAG, "Auth %s", enabled ? "ENABLED" : "DISABLED");
|
|
|
|
auth_enabled_event_data_t event = { .enabled = enabled };
|
|
esp_event_post(AUTH_EVENTS, AUTH_EVENT_ENABLED_CHANGED, &event, sizeof(event), portMAX_DELAY);
|
|
}
|
|
|
|
bool auth_is_enabled(void) {
|
|
return enabled;
|
|
}
|
|
|
|
bool auth_add_tag(const char *tag) {
|
|
if (tag_count >= MAX_TAGS) return false;
|
|
if (!tag || strlen(tag) >= AUTH_TAG_MAX_LEN) return false;
|
|
if (is_tag_valid(tag)) return true;
|
|
|
|
strncpy(valid_tags[tag_count], tag, AUTH_TAG_MAX_LEN - 1);
|
|
valid_tags[tag_count][AUTH_TAG_MAX_LEN - 1] = '\0';
|
|
tag_count++;
|
|
ESP_LOGI(TAG, "Tag added: %s", tag);
|
|
return true;
|
|
}
|
|
|
|
bool auth_remove_tag(const char *tag) {
|
|
for (int i = 0; i < tag_count; i++) {
|
|
if (strncmp(valid_tags[i], tag, AUTH_TAG_MAX_LEN) == 0) {
|
|
for (int j = i; j < tag_count - 1; j++) {
|
|
strncpy(valid_tags[j], valid_tags[j + 1], AUTH_TAG_MAX_LEN);
|
|
}
|
|
tag_count--;
|
|
ESP_LOGI(TAG, "Tag removed: %s", tag);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool auth_tag_exists(const char *tag) {
|
|
return is_tag_valid(tag);
|
|
}
|
|
|
|
void auth_list_tags(void) {
|
|
ESP_LOGI(TAG, "Registered Tags (%d):", tag_count);
|
|
for (int i = 0; i < tag_count; i++) {
|
|
ESP_LOGI(TAG, "- %s", valid_tags[i]);
|
|
}
|
|
}
|
|
|
|
void auth_init(void) {
|
|
load_auth_config(); // carrega estado de ativação
|
|
|
|
if (enabled) {
|
|
initWiegand(); // só inicia se estiver habilitado
|
|
ESP_LOGI(TAG, "Wiegand reader initialized (Auth enabled)");
|
|
} else {
|
|
ESP_LOGI(TAG, "Auth disabled, Wiegand reader not started");
|
|
}
|
|
|
|
auth_enabled_event_data_t evt = { .enabled = enabled };
|
|
esp_event_post(AUTH_EVENTS, AUTH_EVENT_INIT, &evt, sizeof(evt), portMAX_DELAY);
|
|
|
|
ESP_LOGI(TAG, "Estado inicial AUTH enviado (enabled = %d)", enabled);
|
|
}
|
|
|
|
void auth_process_tag(const char *tag) {
|
|
if (!tag || !auth_is_enabled()) {
|
|
ESP_LOGW(TAG, "Auth disabled or NULL tag received.");
|
|
return;
|
|
}
|
|
|
|
auth_tag_event_data_t event;
|
|
strncpy(event.tag, tag, AUTH_EVENT_TAG_MAX_LEN - 1);
|
|
event.tag[AUTH_EVENT_TAG_MAX_LEN - 1] = '\0';
|
|
event.authorized = is_tag_valid(tag);
|
|
|
|
ESP_LOGI(TAG, "Tag %s: %s", tag, event.authorized ? "AUTHORIZED" : "DENIED");
|
|
|
|
esp_event_post(AUTH_EVENTS, AUTH_EVENT_TAG_PROCESSED, &event, sizeof(event), portMAX_DELAY);
|
|
}
|
|
|
|
// === Fim de: components/auth/src/auth.c ===
|
|
|
|
|
|
// === Início de: components/auth/src/wiegand_reader.c ===
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#include <freertos/queue.h>
|
|
#include <esp_log.h>
|
|
#include <wiegand.h>
|
|
#include "auth.h"
|
|
|
|
#define CONFIG_EXAMPLE_BUF_SIZE 50
|
|
|
|
static const char *TAG = "WiegandReader";
|
|
|
|
static wiegand_reader_t reader;
|
|
static QueueHandle_t queue = NULL;
|
|
|
|
typedef struct {
|
|
uint8_t data[CONFIG_EXAMPLE_BUF_SIZE];
|
|
size_t bits;
|
|
} data_packet_t;
|
|
|
|
static void reader_callback(wiegand_reader_t *r) {
|
|
data_packet_t p;
|
|
p.bits = r->bits;
|
|
memcpy(p.data, r->buf, CONFIG_EXAMPLE_BUF_SIZE);
|
|
xQueueSendToBack(queue, &p, 0);
|
|
}
|
|
|
|
static void wiegand_task(void *arg) {
|
|
queue = xQueueCreate(5, sizeof(data_packet_t));
|
|
if (!queue) {
|
|
ESP_LOGE(TAG, "Failed to create queue");
|
|
vTaskDelete(NULL);
|
|
return;
|
|
}
|
|
|
|
ESP_ERROR_CHECK(wiegand_reader_init(&reader, 19, 18,
|
|
true, CONFIG_EXAMPLE_BUF_SIZE, reader_callback, WIEGAND_MSB_FIRST, WIEGAND_LSB_FIRST));
|
|
|
|
data_packet_t p;
|
|
while (1) {
|
|
ESP_LOGI(TAG, "Waiting for Wiegand data...");
|
|
if (xQueueReceive(queue, &p, portMAX_DELAY) == pdPASS) {
|
|
ESP_LOGI(TAG, "Bits received: %d", p.bits);
|
|
|
|
char tag[20] = {0};
|
|
|
|
if (p.bits == 26) {
|
|
snprintf(tag, sizeof(tag), "%03d%03d%03d", p.data[0], p.data[1], p.data[2]);
|
|
} else if (p.bits == 34) {
|
|
snprintf(tag, sizeof(tag), "%03d%03d%03d%03d", p.data[0], p.data[1], p.data[2], p.data[3]);
|
|
} else {
|
|
ESP_LOGW(TAG, "Unsupported bit length: %d", (int)p.bits);
|
|
continue;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Tag read: %s", tag);
|
|
auth_process_tag(tag); // agora delega toda a lógica à auth.c
|
|
}
|
|
}
|
|
}
|
|
|
|
void initWiegand(void) {
|
|
ESP_LOGI(TAG, "Initializing Wiegand reader");
|
|
xTaskCreate(wiegand_task, TAG, configMINIMAL_STACK_SIZE * 4, NULL, 4, NULL);
|
|
}
|
|
|
|
// === Fim de: components/auth/src/wiegand_reader.c ===
|
|
|
|
|
|
// === Início de: components/auth/include/auth.h ===
|
|
#ifndef AUTH_H
|
|
#define AUTH_H
|
|
|
|
#include <stdbool.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/// Tamanho máximo de uma tag RFID (incluindo '\0')
|
|
#define AUTH_TAG_MAX_LEN 20
|
|
|
|
/// Estrutura de evento emitida após leitura de uma tag
|
|
typedef struct {
|
|
char tag[AUTH_TAG_MAX_LEN]; ///< Tag lida
|
|
bool authorized; ///< true se a tag for reconhecida como válida
|
|
} auth_event_t;
|
|
|
|
/**
|
|
* @brief Inicializa o sistema de autenticação.
|
|
*
|
|
* - Carrega a configuração (enabled) da NVS
|
|
* - Inicia o leitor Wiegand
|
|
* - Emite evento AUTH_EVENT_INIT com estado atual
|
|
*/
|
|
void auth_init(void);
|
|
|
|
/**
|
|
* @brief Ativa ou desativa o uso de autenticação via RFID.
|
|
*
|
|
* Esta configuração é persistida em NVS. Se desativado, o sistema
|
|
* considerará todas as autorizações como aceitas.
|
|
*
|
|
* @param value true para ativar, false para desativar
|
|
*/
|
|
void auth_set_enabled(bool value);
|
|
|
|
/**
|
|
* @brief Verifica se o sistema de autenticação está habilitado.
|
|
*/
|
|
bool auth_is_enabled(void);
|
|
|
|
/**
|
|
* @brief Adiciona uma nova tag RFID à lista de autorizadas.
|
|
*
|
|
* @param tag String da tag (máx AUTH_TAG_MAX_LEN-1)
|
|
* @return true se a tag foi adicionada, false se já existia ou inválida
|
|
*/
|
|
bool auth_add_tag(const char *tag);
|
|
|
|
/**
|
|
* @brief Remove uma tag previamente cadastrada.
|
|
*
|
|
* @param tag String da tag
|
|
* @return true se foi removida, false se não encontrada
|
|
*/
|
|
bool auth_remove_tag(const char *tag);
|
|
|
|
/**
|
|
* @brief Verifica se uma tag já está registrada como válida.
|
|
*/
|
|
bool auth_tag_exists(const char *tag);
|
|
|
|
/**
|
|
* @brief Lista todas as tags válidas atualmente registradas (via logs).
|
|
*/
|
|
void auth_list_tags(void);
|
|
|
|
/**
|
|
* @brief Processa uma tag RFID lida (chamada normalmente pelo leitor).
|
|
*
|
|
* - Verifica validade
|
|
* - Emite evento AUTH_EVENT_TAG_PROCESSED
|
|
* - Inicia timer de expiração se autorizada
|
|
*/
|
|
void auth_process_tag(const char *tag);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // AUTH_H
|
|
|
|
// === Fim de: components/auth/include/auth.h ===
|
|
|
|
|
|
// === Início de: components/auth/include/auth_events.h ===
|
|
#pragma once
|
|
#include "esp_event.h"
|
|
|
|
#define AUTH_EVENT_TAG_MAX_LEN 32
|
|
|
|
ESP_EVENT_DECLARE_BASE(AUTH_EVENTS);
|
|
|
|
typedef enum {
|
|
AUTH_EVENT_TAG_PROCESSED,
|
|
AUTH_EVENT_ENABLED_CHANGED,
|
|
AUTH_EVENT_INIT,
|
|
} auth_event_id_t;
|
|
|
|
typedef struct {
|
|
char tag[AUTH_EVENT_TAG_MAX_LEN];
|
|
bool authorized;
|
|
} auth_tag_event_data_t;
|
|
|
|
typedef struct {
|
|
bool enabled;
|
|
} auth_enabled_event_data_t;
|
|
|
|
// === Fim de: components/auth/include/auth_events.h ===
|
|
|
|
|
|
// === Início de: components/auth/include/wiegand.h ===
|
|
/*
|
|
* Copyright (c) 2021 Ruslan V. Uss <unclerus@gmail.com>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the copyright holder nor the names of itscontributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/**
|
|
* @file wiegand.h
|
|
* @defgroup wiegand wiegand
|
|
* @{
|
|
*
|
|
* ESP-IDF Wiegand protocol receiver
|
|
*
|
|
* Copyright (c) 2021 Ruslan V. Uss <unclerus@gmail.com>
|
|
*
|
|
* BSD Licensed as described in the file LICENSE
|
|
*/
|
|
#ifndef __WIEGAND_H__
|
|
#define __WIEGAND_H__
|
|
|
|
#include <driver/gpio.h>
|
|
#include <esp_err.h>
|
|
#include <esp_timer.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef struct wiegand_reader wiegand_reader_t;
|
|
|
|
typedef void (*wiegand_callback_t)(wiegand_reader_t *reader);
|
|
|
|
/**
|
|
* Bit and byte order of data
|
|
*/
|
|
typedef enum {
|
|
WIEGAND_MSB_FIRST = 0,
|
|
WIEGAND_LSB_FIRST
|
|
} wiegand_order_t;
|
|
|
|
/**
|
|
* Wiegand reader descriptor
|
|
*/
|
|
struct wiegand_reader
|
|
{
|
|
gpio_num_t gpio_d0, gpio_d1;
|
|
wiegand_callback_t callback;
|
|
wiegand_order_t bit_order;
|
|
wiegand_order_t byte_order;
|
|
|
|
uint8_t *buf;
|
|
size_t size;
|
|
size_t bits;
|
|
esp_timer_handle_t timer;
|
|
bool start_parity;
|
|
bool enabled;
|
|
};
|
|
|
|
/**
|
|
* @brief Create and initialize reader instance.
|
|
*
|
|
* @param reader Reader descriptor
|
|
* @param gpio_d0 GPIO pin for D0
|
|
* @param gpio_d1 GPIO pin for D0
|
|
* @param internal_pullups Enable internal pull-up resistors for D0 and D1 GPIO
|
|
* @param buf_size Reader buffer size in bytes, must be large enough to
|
|
* contain entire Wiegand key
|
|
* @param callback Callback function for processing received codes
|
|
* @param bit_order Bit order of data
|
|
* @param byte_order Byte order of data
|
|
* @return `ESP_OK` on success
|
|
*/
|
|
esp_err_t wiegand_reader_init(wiegand_reader_t *reader, gpio_num_t gpio_d0, gpio_num_t gpio_d1,
|
|
bool internal_pullups, size_t buf_size, wiegand_callback_t callback, wiegand_order_t bit_order,
|
|
wiegand_order_t byte_order);
|
|
|
|
/**
|
|
* @brief Disable reader
|
|
*
|
|
* While reader is disabled, it will not receive new data
|
|
*
|
|
* @param reader Reader descriptor
|
|
* @return `ESP_OK` on success
|
|
*/
|
|
esp_err_t wiegand_reader_disable(wiegand_reader_t *reader);
|
|
|
|
/**
|
|
* @brief Enable reader
|
|
*
|
|
* @param reader Reader descriptor
|
|
* @return `ESP_OK` on success
|
|
*/
|
|
esp_err_t wiegand_reader_enable(wiegand_reader_t *reader);
|
|
|
|
/**
|
|
* @brief Delete reader instance.
|
|
*
|
|
* @param reader Reader descriptor
|
|
* @return `ESP_OK` on success
|
|
*/
|
|
esp_err_t wiegand_reader_done(wiegand_reader_t *reader);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/**@}*/
|
|
|
|
#endif /* __WIEGAND_H__ */
|
|
|
|
// === Fim de: components/auth/include/wiegand.h ===
|
|
|
|
|
|
// === Início de: components/auth/include/wiegand_reader.h ===
|
|
#ifndef WIEGAND_READER_H
|
|
#define WIEGAND_READER_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
void initWiegand(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // WIEGAND_READER_H
|
|
|
|
// === Fim de: components/auth/include/wiegand_reader.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/ocpp_api.c ===
|
|
// =========================
|
|
// ocpp_api.c
|
|
// =========================
|
|
#include "ocpp_api.h"
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
|
|
static const char *TAG = "ocpp_api";
|
|
|
|
static struct {
|
|
char url[256];
|
|
char chargeBoxId[128];
|
|
char certificate[256];
|
|
char privateKey[256];
|
|
} ocpp_config = {"", "", "", ""};
|
|
|
|
static esp_err_t ocpp_get_status_handler(httpd_req_t *req) {
|
|
httpd_resp_set_type(req, "application/json");
|
|
cJSON *status = cJSON_CreateObject();
|
|
cJSON_AddStringToObject(status, "status", "connected");
|
|
char *str = cJSON_Print(status);
|
|
httpd_resp_sendstr(req, str);
|
|
free(str);
|
|
cJSON_Delete(status);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t ocpp_get_config_handler(httpd_req_t *req) {
|
|
httpd_resp_set_type(req, "application/json");
|
|
cJSON *json = cJSON_CreateObject();
|
|
cJSON_AddStringToObject(json, "url", ocpp_config.url);
|
|
cJSON_AddStringToObject(json, "chargeBoxId", ocpp_config.chargeBoxId);
|
|
cJSON_AddStringToObject(json, "certificate", ocpp_config.certificate);
|
|
cJSON_AddStringToObject(json, "privateKey", ocpp_config.privateKey);
|
|
char *str = cJSON_Print(json);
|
|
httpd_resp_sendstr(req, str);
|
|
free(str);
|
|
cJSON_Delete(json);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t ocpp_post_config_handler(httpd_req_t *req) {
|
|
char buf[512];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
if (len <= 0) {
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Empty body");
|
|
return ESP_FAIL;
|
|
}
|
|
buf[len] = '\0';
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) {
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
|
|
return ESP_FAIL;
|
|
}
|
|
cJSON *url = cJSON_GetObjectItem(json, "url");
|
|
if (url) strlcpy(ocpp_config.url, url->valuestring, sizeof(ocpp_config.url));
|
|
cJSON *id = cJSON_GetObjectItem(json, "chargeBoxId");
|
|
if (id) strlcpy(ocpp_config.chargeBoxId, id->valuestring, sizeof(ocpp_config.chargeBoxId));
|
|
cJSON *cert = cJSON_GetObjectItem(json, "certificate");
|
|
if (cert) strlcpy(ocpp_config.certificate, cert->valuestring, sizeof(ocpp_config.certificate));
|
|
cJSON *key = cJSON_GetObjectItem(json, "privateKey");
|
|
if (key) strlcpy(ocpp_config.privateKey, key->valuestring, sizeof(ocpp_config.privateKey));
|
|
cJSON_Delete(json);
|
|
httpd_resp_sendstr(req, "OCPP config atualizada com sucesso");
|
|
return ESP_OK;
|
|
}
|
|
|
|
void register_ocpp_handlers(httpd_handle_t server, void *ctx) {
|
|
httpd_uri_t status_uri = {
|
|
.uri = "/api/v1/ocpp",
|
|
.method = HTTP_GET,
|
|
.handler = ocpp_get_status_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &status_uri);
|
|
|
|
httpd_uri_t get_uri = {
|
|
.uri = "/api/v1/config/ocpp",
|
|
.method = HTTP_GET,
|
|
.handler = ocpp_get_config_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &get_uri);
|
|
|
|
httpd_uri_t post_uri = {
|
|
.uri = "/api/v1/config/ocpp",
|
|
.method = HTTP_POST,
|
|
.handler = ocpp_post_config_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &post_uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/ocpp_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/static_file_api.c ===
|
|
#include "static_file_api.h"
|
|
#include "esp_log.h"
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include "esp_vfs.h"
|
|
|
|
static const char *TAG = "static_file_api";
|
|
|
|
#define FILE_PATH_MAX (ESP_VFS_PATH_MAX + 128)
|
|
#define SCRATCH_BUFSIZE (10240)
|
|
|
|
typedef struct rest_server_context {
|
|
char base_path[ESP_VFS_PATH_MAX + 1];
|
|
char scratch[SCRATCH_BUFSIZE];
|
|
} rest_server_context_t;
|
|
|
|
#define CHECK_FILE_EXTENSION(filename, ext) \
|
|
(strcasecmp(&filename[strlen(filename) - strlen(ext)], ext) == 0)
|
|
|
|
static esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filepath) {
|
|
const char *type = "text/plain";
|
|
if (CHECK_FILE_EXTENSION(filepath, ".html")) type = "text/html";
|
|
else if (CHECK_FILE_EXTENSION(filepath, ".js")) type = "application/javascript";
|
|
else if (CHECK_FILE_EXTENSION(filepath, ".css")) type = "text/css";
|
|
else if (CHECK_FILE_EXTENSION(filepath, ".png")) type = "image/png";
|
|
else if (CHECK_FILE_EXTENSION(filepath, ".ico")) type = "image/x-icon";
|
|
else if (CHECK_FILE_EXTENSION(filepath, ".svg")) type = "image/svg+xml";
|
|
return httpd_resp_set_type(req, type);
|
|
}
|
|
|
|
static esp_err_t static_get_handler(httpd_req_t *req) {
|
|
char filepath[FILE_PATH_MAX];
|
|
rest_server_context_t *ctx = (rest_server_context_t *) req->user_ctx;
|
|
|
|
strlcpy(filepath, ctx->base_path, sizeof(filepath));
|
|
if (req->uri[strlen(req->uri) - 1] == '/') {
|
|
strlcat(filepath, "/index.html", sizeof(filepath));
|
|
} else {
|
|
strlcat(filepath, req->uri, sizeof(filepath));
|
|
}
|
|
|
|
int fd = open(filepath, O_RDONLY, 0);
|
|
if (fd == -1) {
|
|
// fallback para /index.html (SPA)
|
|
ESP_LOGW(TAG, "Arquivo não encontrado: %s. Tentando index.html", filepath);
|
|
strlcpy(filepath, ctx->base_path, sizeof(filepath));
|
|
strlcat(filepath, "/index.html", sizeof(filepath));
|
|
fd = open(filepath, O_RDONLY, 0);
|
|
if (fd == -1) {
|
|
httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Arquivo não encontrado");
|
|
return ESP_FAIL;
|
|
}
|
|
}
|
|
|
|
set_content_type_from_file(req, filepath);
|
|
|
|
char *chunk = ctx->scratch;
|
|
ssize_t read_bytes;
|
|
do {
|
|
read_bytes = read(fd, chunk, SCRATCH_BUFSIZE);
|
|
if (read_bytes == -1) {
|
|
ESP_LOGE(TAG, "Erro lendo arquivo: %s", filepath);
|
|
close(fd);
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Erro ao ler arquivo");
|
|
return ESP_FAIL;
|
|
} else if (read_bytes > 0) {
|
|
if (httpd_resp_send_chunk(req, chunk, read_bytes) != ESP_OK) {
|
|
close(fd);
|
|
httpd_resp_sendstr_chunk(req, NULL);
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Erro ao enviar arquivo");
|
|
return ESP_FAIL;
|
|
}
|
|
}
|
|
} while (read_bytes > 0);
|
|
|
|
close(fd);
|
|
httpd_resp_send_chunk(req, NULL, 0);
|
|
return ESP_OK;
|
|
}
|
|
|
|
void register_static_file_handlers(httpd_handle_t server, void *ctx) {
|
|
httpd_uri_t uri = {
|
|
.uri = "/*",
|
|
.method = HTTP_GET,
|
|
.handler = static_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/static_file_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/meters_settings_api.c ===
|
|
#include "meters_settings_api.h"
|
|
#include "meter_manager.h" // Atualizado para usar o novo manager
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
|
|
static const char *TAG = "meters_settings_api";
|
|
|
|
// Função para recuperar as configurações dos contadores
|
|
static esp_err_t meters_config_get_handler(httpd_req_t *req) {
|
|
ESP_LOGI(TAG, "Received GET request for /api/v1/config/meters");
|
|
|
|
httpd_resp_set_type(req, "application/json");
|
|
|
|
cJSON *config = cJSON_CreateObject();
|
|
|
|
// Recuperando as configurações dos contadores
|
|
meter_type_t gridmeterType = meter_manager_grid_get_model();
|
|
meter_type_t evsemeterType = meter_manager_evse_get_model();
|
|
|
|
ESP_LOGI(TAG, "Grid meter type: %s", meter_type_to_str(gridmeterType));
|
|
ESP_LOGI(TAG, "EVSE meter type: %s", meter_type_to_str(evsemeterType));
|
|
|
|
// Adicionando os tipos de contadores ao objeto JSON
|
|
cJSON_AddStringToObject(config, "gridmeter", meter_type_to_str(gridmeterType));
|
|
cJSON_AddStringToObject(config, "evsemeter", meter_type_to_str(evsemeterType));
|
|
|
|
// Convertendo o objeto JSON para uma string
|
|
const char *json_str = cJSON_Print(config);
|
|
ESP_LOGI(TAG, "Returning meters config: %s", json_str);
|
|
|
|
httpd_resp_sendstr(req, json_str);
|
|
|
|
// Liberação da memória
|
|
free((void *)json_str);
|
|
cJSON_Delete(config);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
// Função para atualizar as configurações dos contadores
|
|
static esp_err_t meters_config_post_handler(httpd_req_t *req) {
|
|
ESP_LOGI(TAG, "Received POST request for /api/v1/config/meters");
|
|
|
|
char buf[512];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
|
|
if (len <= 0) {
|
|
ESP_LOGE(TAG, "Received empty body in POST request");
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Empty body");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
buf[len] = '\0'; // Garantir que a string está terminada
|
|
|
|
ESP_LOGI(TAG, "Received POST data: %s", buf);
|
|
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) {
|
|
ESP_LOGE(TAG, "Failed to parse JSON data");
|
|
// Resposta detalhada de erro
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON format");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
// Atualizando os contadores
|
|
cJSON *gridmeter = cJSON_GetObjectItem(json, "gridmeter");
|
|
if (gridmeter) {
|
|
meter_type_t gridType = string_to_meter_type(gridmeter->valuestring); // Usando a função string_to_meter_type
|
|
ESP_LOGI(TAG, "Updating grid meter type to: %s", gridmeter->valuestring);
|
|
meter_manager_grid_set_model(gridType);
|
|
}
|
|
|
|
cJSON *evsemeter = cJSON_GetObjectItem(json, "evsemeter");
|
|
if (evsemeter) {
|
|
meter_type_t evseType = string_to_meter_type(evsemeter->valuestring); // Usando a função string_to_meter_type
|
|
ESP_LOGI(TAG, "Updating EVSE meter type to: %s", evsemeter->valuestring);
|
|
meter_manager_evse_set_model(evseType);
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
httpd_resp_sendstr(req, "Meters updated successfully");
|
|
|
|
ESP_LOGI(TAG, "Meters configuration updated successfully");
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
// Registrando os manipuladores de URI para os contadores
|
|
void register_meters_settings_handlers(httpd_handle_t server, void *ctx) {
|
|
ESP_LOGI(TAG, "Registering URI handlers for meters settings");
|
|
|
|
// URI para o método GET
|
|
httpd_uri_t meters_get_uri = {
|
|
.uri = "/api/v1/config/meters",
|
|
.method = HTTP_GET,
|
|
.handler = meters_config_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
ESP_LOGI(TAG, "Registering GET handler for /api/v1/config/meters");
|
|
httpd_register_uri_handler(server, &meters_get_uri);
|
|
|
|
// URI para o método POST
|
|
httpd_uri_t meters_post_uri = {
|
|
.uri = "/api/v1/config/meters",
|
|
.method = HTTP_POST,
|
|
.handler = meters_config_post_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
ESP_LOGI(TAG, "Registering POST handler for /api/v1/config/meters");
|
|
httpd_register_uri_handler(server, &meters_post_uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/meters_settings_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/rest_main.c ===
|
|
#include "rest_main.h"
|
|
#include "evse_settings_api.h"
|
|
#include "meters_settings_api.h"
|
|
#include "loadbalancing_settings_api.h"
|
|
#include "network_api.h"
|
|
#include "ocpp_api.h"
|
|
#include "auth_api.h"
|
|
#include "dashboard_api.h"
|
|
#include "static_file_api.h"
|
|
#include "esp_log.h"
|
|
|
|
|
|
static const char *TAG = "rest_main";
|
|
|
|
esp_err_t rest_server_init(const char *base_path) {
|
|
ESP_LOGI(TAG, "Initializing REST API with base path: %s", base_path);
|
|
|
|
rest_server_context_t *ctx = calloc(1, sizeof(rest_server_context_t));
|
|
if (!ctx) {
|
|
ESP_LOGE(TAG, "Failed to allocate memory for REST context");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
strlcpy(ctx->base_path, base_path, sizeof(ctx->base_path));
|
|
|
|
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
|
|
config.uri_match_fn = httpd_uri_match_wildcard;
|
|
config.max_uri_handlers = 32;
|
|
|
|
httpd_handle_t server = NULL;
|
|
esp_err_t err = httpd_start(&server, &config);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to start HTTP server: %s", esp_err_to_name(err));
|
|
free(ctx);
|
|
return err;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "HTTP server started successfully");
|
|
|
|
// Register endpoint groups
|
|
register_evse_settings_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_network_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_ocpp_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_auth_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_dashboard_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_meters_settings_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_loadbalancing_settings_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
register_static_file_handlers(server, ctx); // Apenas chamando a função sem comparação
|
|
|
|
ESP_LOGI(TAG, "All REST API endpoint groups registered successfully");
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/rest_main.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/network_api.c ===
|
|
// =========================
|
|
// network_api.c
|
|
// =========================
|
|
|
|
#include "network_api.h"
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
#include "wifi.h"
|
|
#include "mqtt.h"
|
|
|
|
static const char *TAG = "network_api";
|
|
|
|
typedef struct {
|
|
bool enabled;
|
|
char ssid[33];
|
|
char password[65];
|
|
} wifi_task_data_t;
|
|
|
|
|
|
static void wifi_apply_config_task(void *param) {
|
|
wifi_task_data_t *data = (wifi_task_data_t *)param;
|
|
ESP_LOGI("wifi_task", "Applying Wi-Fi config in background task");
|
|
wifi_set_config(data->enabled, data->ssid, data->password);
|
|
free(data);
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
static esp_err_t wifi_get_handler(httpd_req_t *req) {
|
|
ESP_LOGI(TAG, "Handling GET /api/v1/config/wifi");
|
|
|
|
httpd_resp_set_type(req, "application/json");
|
|
|
|
// Obter dados da NVS via wifi.c
|
|
bool enabled = wifi_get_enabled();
|
|
char ssid[33] = {0};
|
|
char password[65] = {0};
|
|
|
|
wifi_get_ssid(ssid);
|
|
wifi_get_password(password);
|
|
|
|
// Criar JSON
|
|
cJSON *json = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(json, "enabled", enabled);
|
|
cJSON_AddStringToObject(json, "ssid", ssid);
|
|
cJSON_AddStringToObject(json, "password", password);
|
|
|
|
// Enviar resposta
|
|
char *response = cJSON_Print(json);
|
|
httpd_resp_sendstr(req, response);
|
|
|
|
// Limpeza
|
|
free(response);
|
|
cJSON_Delete(json);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t wifi_post_handler(httpd_req_t *req) {
|
|
ESP_LOGI(TAG, "Handling POST /api/v1/config/wifi");
|
|
|
|
char buf[512];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
if (len <= 0) return ESP_FAIL;
|
|
buf[len] = '\0';
|
|
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) return ESP_FAIL;
|
|
|
|
// Valores padrão
|
|
bool enabled = false;
|
|
const char *ssid = NULL;
|
|
const char *password = NULL;
|
|
|
|
cJSON *j_enabled = cJSON_GetObjectItem(json, "enabled");
|
|
if (cJSON_IsBool(j_enabled)) enabled = j_enabled->valueint;
|
|
|
|
cJSON *j_ssid = cJSON_GetObjectItem(json, "ssid");
|
|
if (cJSON_IsString(j_ssid)) ssid = j_ssid->valuestring;
|
|
|
|
cJSON *j_password = cJSON_GetObjectItem(json, "password");
|
|
if (cJSON_IsString(j_password)) password = j_password->valuestring;
|
|
|
|
// Enviar resposta antes de alterar Wi-Fi
|
|
httpd_resp_sendstr(req, "Wi-Fi config atualizada com sucesso");
|
|
|
|
// Alocar struct para passar para a task
|
|
wifi_task_data_t *task_data = malloc(sizeof(wifi_task_data_t));
|
|
if (!task_data) {
|
|
cJSON_Delete(json);
|
|
ESP_LOGE(TAG, "Memory allocation failed for Wi-Fi task");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
task_data->enabled = enabled;
|
|
strncpy(task_data->ssid, ssid ? ssid : "", sizeof(task_data->ssid));
|
|
strncpy(task_data->password, password ? password : "", sizeof(task_data->password));
|
|
|
|
// Criar task normal com função C
|
|
xTaskCreate(
|
|
wifi_apply_config_task,
|
|
"wifi_config_task",
|
|
4096,
|
|
task_data,
|
|
3,
|
|
NULL
|
|
);
|
|
|
|
cJSON_Delete(json);
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
static esp_err_t config_mqtt_get_handler(httpd_req_t *req)
|
|
{
|
|
ESP_LOGI(TAG, "Handling GET /api/v1/config/mqtt");
|
|
|
|
httpd_resp_set_type(req, "application/json");
|
|
|
|
bool enabled = mqtt_get_enabled();
|
|
char server[64] = {0};
|
|
char base_topic[32] = {0};
|
|
char username[32] = {0};
|
|
char password[64] = {0};
|
|
uint16_t periodicity = mqtt_get_periodicity();
|
|
|
|
mqtt_get_server(server);
|
|
mqtt_get_base_topic(base_topic);
|
|
mqtt_get_user(username);
|
|
mqtt_get_password(password);
|
|
|
|
ESP_LOGI(TAG, "MQTT Config:");
|
|
ESP_LOGI(TAG, " Enabled: %s", enabled ? "true" : "false");
|
|
ESP_LOGI(TAG, " Server: %s", server);
|
|
ESP_LOGI(TAG, " Topic: %s", base_topic);
|
|
ESP_LOGI(TAG, " Username: %s", username);
|
|
ESP_LOGI(TAG, " Password: %s", password);
|
|
ESP_LOGI(TAG, " Periodicity: %d", periodicity);
|
|
|
|
cJSON *config = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(config, "enabled", enabled);
|
|
cJSON_AddStringToObject(config, "host", server);
|
|
cJSON_AddNumberToObject(config, "port", 1883);
|
|
cJSON_AddStringToObject(config, "username", username);
|
|
cJSON_AddStringToObject(config, "password", password);
|
|
cJSON_AddStringToObject(config, "topic", base_topic);
|
|
cJSON_AddNumberToObject(config, "periodicity", periodicity);
|
|
|
|
const char *config_str = cJSON_Print(config);
|
|
httpd_resp_sendstr(req, config_str);
|
|
|
|
free((void *)config_str);
|
|
cJSON_Delete(config);
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
static esp_err_t config_mqtt_post_handler(httpd_req_t *req)
|
|
{
|
|
ESP_LOGI(TAG, "Handling POST /api/v1/config/mqtt");
|
|
|
|
char buf[512];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
if (len <= 0) {
|
|
ESP_LOGE(TAG, "Failed to read request body");
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
|
|
return ESP_FAIL;
|
|
}
|
|
buf[len] = '\0';
|
|
ESP_LOGI(TAG, "Received JSON: %s", buf);
|
|
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) {
|
|
ESP_LOGE(TAG, "Invalid JSON format");
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
bool enabled = false;
|
|
const char *host = NULL, *topic = NULL, *username = NULL, *password = NULL;
|
|
int periodicity = 30;
|
|
|
|
if (cJSON_IsBool(cJSON_GetObjectItem(json, "enabled")))
|
|
enabled = cJSON_GetObjectItem(json, "enabled")->valueint;
|
|
|
|
cJSON *j_host = cJSON_GetObjectItem(json, "host");
|
|
if (cJSON_IsString(j_host)) host = j_host->valuestring;
|
|
|
|
cJSON *j_topic = cJSON_GetObjectItem(json, "topic");
|
|
if (cJSON_IsString(j_topic)) topic = j_topic->valuestring;
|
|
|
|
cJSON *j_user = cJSON_GetObjectItem(json, "username");
|
|
if (cJSON_IsString(j_user)) username = j_user->valuestring;
|
|
|
|
cJSON *j_pass = cJSON_GetObjectItem(json, "password");
|
|
if (cJSON_IsString(j_pass)) password = j_pass->valuestring;
|
|
|
|
cJSON *j_periodicity = cJSON_GetObjectItem(json, "periodicity");
|
|
if (cJSON_IsNumber(j_periodicity)) periodicity = j_periodicity->valueint;
|
|
|
|
ESP_LOGI(TAG, "Applying MQTT config:");
|
|
ESP_LOGI(TAG, " Enabled: %s", enabled ? "true" : "false");
|
|
ESP_LOGI(TAG, " Host: %s", host);
|
|
ESP_LOGI(TAG, " Topic: %s", topic);
|
|
ESP_LOGI(TAG, " Username: %s", username);
|
|
ESP_LOGI(TAG, " Password: %s", password);
|
|
ESP_LOGI(TAG, " Periodicity: %d", periodicity);
|
|
|
|
esp_err_t err = mqtt_set_config(enabled, host, topic, username, password, periodicity);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to apply MQTT config (code %d)", err);
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to apply config");
|
|
cJSON_Delete(json);
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
httpd_resp_sendstr(req, "Configuração MQTT atualizada com sucesso");
|
|
cJSON_Delete(json);
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
|
|
void register_network_handlers(httpd_handle_t server, void *ctx) {
|
|
httpd_uri_t wifi_get = {
|
|
.uri = "/api/v1/config/wifi",
|
|
.method = HTTP_GET,
|
|
.handler = wifi_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &wifi_get);
|
|
|
|
httpd_uri_t wifi_post = {
|
|
.uri = "/api/v1/config/wifi",
|
|
.method = HTTP_POST,
|
|
.handler = wifi_post_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &wifi_post);
|
|
|
|
// URI handler for getting MQTT config
|
|
httpd_uri_t config_mqtt_get_uri = {
|
|
.uri = "/api/v1/config/mqtt",
|
|
.method = HTTP_GET,
|
|
.handler = config_mqtt_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &config_mqtt_get_uri);
|
|
|
|
// URI handler for posting MQTT config
|
|
httpd_uri_t config_mqtt_post_uri = {
|
|
.uri = "/api/v1/config/mqtt",
|
|
.method = HTTP_POST,
|
|
.handler = config_mqtt_post_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &config_mqtt_post_uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/network_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/dashboard_api.c ===
|
|
#include "dashboard_api.h"
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
#include "evse_api.h"
|
|
#include "evse_error.h"
|
|
|
|
static const char *TAG = "dashboard_api";
|
|
|
|
static esp_err_t dashboard_get_handler(httpd_req_t *req) {
|
|
httpd_resp_set_type(req, "application/json");
|
|
|
|
// Cria o objeto JSON principal do dashboard
|
|
cJSON *dashboard = cJSON_CreateObject();
|
|
|
|
// Status do sistema
|
|
evse_state_t state = evse_get_state();
|
|
cJSON_AddStringToObject(dashboard, "status", evse_state_to_str(state));
|
|
|
|
// Carregador - informação do carregador 1 (adapte conforme necessário)
|
|
cJSON *chargers = cJSON_CreateArray();
|
|
cJSON *charger1 = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(charger1, "id", 1);
|
|
cJSON_AddStringToObject(charger1, "status", evse_state_to_str(state));
|
|
cJSON_AddNumberToObject(charger1, "current", evse_get_charging_current() / 10);
|
|
cJSON_AddNumberToObject(charger1, "maxCurrent", evse_get_max_charging_current());
|
|
|
|
// Calcular a potência com base na corrente (considerando 230V)
|
|
int power = (evse_get_charging_current() / 10) * 230;
|
|
cJSON_AddNumberToObject(charger1, "power", power);
|
|
|
|
cJSON_AddItemToArray(chargers, charger1);
|
|
cJSON_AddItemToObject(dashboard, "chargers", chargers);
|
|
|
|
// Consumo e tempo de carregamento
|
|
cJSON_AddNumberToObject(dashboard, "energyConsumed", evse_get_consumption_limit());
|
|
cJSON_AddNumberToObject(dashboard, "chargingTime", evse_get_charging_time_limit());
|
|
|
|
// Alertas
|
|
cJSON *alerts = cJSON_CreateArray();
|
|
if (evse_is_limit_reached()) {
|
|
cJSON_AddItemToArray(alerts, cJSON_CreateString("Limite de consumo atingido."));
|
|
}
|
|
if (!evse_is_available()) {
|
|
cJSON_AddItemToArray(alerts, cJSON_CreateString("Estação indisponível."));
|
|
}
|
|
if (!evse_is_enabled()) {
|
|
cJSON_AddItemToArray(alerts, cJSON_CreateString("EVSE desativado."));
|
|
}
|
|
cJSON_AddItemToObject(dashboard, "alerts", alerts);
|
|
|
|
// Erros
|
|
uint32_t error_bits = evse_get_error();
|
|
cJSON *errors = cJSON_CreateArray();
|
|
if (error_bits & EVSE_ERR_DIODE_SHORT_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Diodo curto-circuitado"));
|
|
if (error_bits & EVSE_ERR_LOCK_FAULT_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Falha no travamento"));
|
|
if (error_bits & EVSE_ERR_UNLOCK_FAULT_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Falha no destravamento"));
|
|
if (error_bits & EVSE_ERR_RCM_SELFTEST_FAULT_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Falha no autoteste do RCM"));
|
|
if (error_bits & EVSE_ERR_RCM_TRIGGERED_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("RCM disparado"));
|
|
if (error_bits & EVSE_ERR_TEMPERATURE_HIGH_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Temperatura elevada"));
|
|
if (error_bits & EVSE_ERR_PILOT_FAULT_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Erro no sinal piloto"));
|
|
if (error_bits & EVSE_ERR_TEMPERATURE_FAULT_BIT) cJSON_AddItemToArray(errors, cJSON_CreateString("Falha no sensor de temperatura"));
|
|
cJSON_AddItemToObject(dashboard, "errors", errors);
|
|
|
|
// Enviar resposta JSON
|
|
const char *json_str = cJSON_Print(dashboard);
|
|
httpd_resp_sendstr(req, json_str);
|
|
|
|
// Liberar memória
|
|
free((void *)json_str);
|
|
cJSON_Delete(dashboard);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
void register_dashboard_handlers(httpd_handle_t server, void *ctx) {
|
|
httpd_uri_t uri = {
|
|
.uri = "/api/v1/dashboard",
|
|
.method = HTTP_GET,
|
|
.handler = dashboard_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/dashboard_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/auth_api.c ===
|
|
// =========================
|
|
// auth_api.c
|
|
// =========================
|
|
#include "auth_api.h"
|
|
#include "auth.h"
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
|
|
static const char *TAG = "auth_api";
|
|
|
|
static struct {
|
|
char username[128];
|
|
} users[10] = { /*{"admin"}, {"user1"}*/ };
|
|
static int num_users = 2;
|
|
|
|
static esp_err_t auth_methods_get_handler(httpd_req_t *req) {
|
|
httpd_resp_set_type(req, "application/json");
|
|
cJSON *json = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(json, "RFID", auth_is_enabled() );
|
|
char *str = cJSON_PrintUnformatted(json);
|
|
httpd_resp_sendstr(req, str);
|
|
free(str);
|
|
cJSON_Delete(json);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t auth_methods_post_handler(httpd_req_t *req) {
|
|
char buf[256];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
if (len <= 0) {
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Erro ao receber dados");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
buf[len] = '\0';
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) {
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "JSON inválido");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
cJSON *rfid = cJSON_GetObjectItem(json, "RFID");
|
|
if (rfid && cJSON_IsBool(rfid)) {
|
|
auth_set_enabled(cJSON_IsTrue(rfid));
|
|
} else {
|
|
cJSON_Delete(json);
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Campo 'RFID' inválido ou ausente");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
httpd_resp_sendstr(req, "Métodos de autenticação atualizados");
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
static esp_err_t users_get_handler(httpd_req_t *req) {
|
|
httpd_resp_set_type(req, "application/json");
|
|
cJSON *root = cJSON_CreateObject();
|
|
cJSON *list = cJSON_CreateArray();
|
|
for (int i = 0; i < num_users; ++i) {
|
|
cJSON *u = cJSON_CreateObject();
|
|
cJSON_AddStringToObject(u, "username", users[i].username);
|
|
cJSON_AddItemToArray(list, u);
|
|
}
|
|
cJSON_AddItemToObject(root, "users", list);
|
|
char *str = cJSON_Print(root);
|
|
httpd_resp_sendstr(req, str);
|
|
free(str);
|
|
cJSON_Delete(root);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t users_post_handler(httpd_req_t *req) {
|
|
char buf[128];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
if (len <= 0) return ESP_FAIL;
|
|
buf[len] = '\0';
|
|
if (num_users < 10) {
|
|
strlcpy(users[num_users].username, buf, sizeof(users[num_users].username));
|
|
num_users++;
|
|
httpd_resp_sendstr(req, "Usuário adicionado com sucesso");
|
|
} else {
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Limite de usuários atingido");
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t users_delete_handler(httpd_req_t *req) {
|
|
char query[128];
|
|
if (httpd_req_get_url_query_str(req, query, sizeof(query)) == ESP_OK) {
|
|
char username[128];
|
|
if (httpd_query_key_value(query, "username", username, sizeof(username)) == ESP_OK) {
|
|
for (int i = 0; i < num_users; i++) {
|
|
if (strcmp(users[i].username, username) == 0) {
|
|
for (int j = i; j < num_users - 1; j++) {
|
|
users[j] = users[j + 1];
|
|
}
|
|
num_users--;
|
|
httpd_resp_sendstr(req, "Usuário removido com sucesso");
|
|
return ESP_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Usuário não encontrado");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
void register_auth_handlers(httpd_handle_t server, void *ctx) {
|
|
httpd_register_uri_handler(server, &(httpd_uri_t){
|
|
.uri = "/api/v1/config/auth-methods",
|
|
.method = HTTP_GET,
|
|
.handler = auth_methods_get_handler,
|
|
.user_ctx = ctx
|
|
});
|
|
httpd_register_uri_handler(server, &(httpd_uri_t){
|
|
.uri = "/api/v1/config/auth-methods",
|
|
.method = HTTP_POST,
|
|
.handler = auth_methods_post_handler,
|
|
.user_ctx = ctx
|
|
});
|
|
httpd_register_uri_handler(server, &(httpd_uri_t){
|
|
.uri = "/api/v1/config/users",
|
|
.method = HTTP_GET,
|
|
.handler = users_get_handler,
|
|
.user_ctx = ctx
|
|
});
|
|
httpd_register_uri_handler(server, &(httpd_uri_t){
|
|
.uri = "/api/v1/config/users",
|
|
.method = HTTP_POST,
|
|
.handler = users_post_handler,
|
|
.user_ctx = ctx
|
|
});
|
|
httpd_register_uri_handler(server, &(httpd_uri_t){
|
|
.uri = "/api/v1/config/users",
|
|
.method = HTTP_DELETE,
|
|
.handler = users_delete_handler,
|
|
.user_ctx = ctx
|
|
});
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/auth_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/loadbalancing_settings_api.c ===
|
|
#include "loadbalancing_settings_api.h"
|
|
#include "loadbalancer.h"
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
|
|
static const char *TAG = "loadbalancing_settings_api";
|
|
|
|
// GET Handler: Retorna configurações atuais de load balancing
|
|
static esp_err_t loadbalancing_config_get_handler(httpd_req_t *req) {
|
|
bool enabled = loadbalancer_is_enabled();
|
|
uint8_t currentLimit = load_balancing_get_max_grid_current();
|
|
|
|
ESP_LOGI(TAG, "Fetching load balancing settings: enabled = %d, currentLimit = %u", enabled, currentLimit);
|
|
|
|
httpd_resp_set_type(req, "application/json");
|
|
|
|
cJSON *config = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(config, "loadBalancingEnabled", enabled);
|
|
cJSON_AddNumberToObject(config, "loadBalancingCurrentLimit", currentLimit);
|
|
|
|
const char *json_str = cJSON_Print(config);
|
|
httpd_resp_sendstr(req, json_str);
|
|
|
|
ESP_LOGI(TAG, "Returned config: %s", json_str);
|
|
|
|
free((void *)json_str);
|
|
cJSON_Delete(config);
|
|
return ESP_OK;
|
|
}
|
|
|
|
// POST Handler: Atualiza configurações de load balancing
|
|
static esp_err_t loadbalancing_config_post_handler(httpd_req_t *req) {
|
|
char buf[512];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
|
|
if (len <= 0) {
|
|
ESP_LOGE(TAG, "Received empty POST body");
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Empty body");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
buf[len] = '\0';
|
|
ESP_LOGI(TAG, "Received POST data: %s", buf);
|
|
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) {
|
|
ESP_LOGE(TAG, "Invalid JSON");
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
// Atualizar estado habilitado
|
|
cJSON *enabled_item = cJSON_GetObjectItem(json, "loadBalancingEnabled");
|
|
if (enabled_item && cJSON_IsBool(enabled_item)) {
|
|
bool isEnabled = cJSON_IsTrue(enabled_item);
|
|
loadbalancer_set_enabled(isEnabled);
|
|
ESP_LOGI(TAG, "Updated loadBalancingEnabled to: %d", isEnabled);
|
|
}
|
|
|
|
// Atualizar limite de corrente
|
|
cJSON *limit_item = cJSON_GetObjectItem(json, "loadBalancingCurrentLimit");
|
|
if (limit_item && cJSON_IsNumber(limit_item)) {
|
|
uint8_t currentLimit = (uint8_t)limit_item->valuedouble;
|
|
|
|
// Validar intervalo
|
|
if (currentLimit < 6 || currentLimit > 100) {
|
|
ESP_LOGW(TAG, "Rejected invalid currentLimit: %d", currentLimit);
|
|
cJSON_Delete(json);
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid currentLimit (must be 6-100)");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
esp_err_t err = load_balancing_set_max_grid_current(currentLimit);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to save currentLimit: %s", esp_err_to_name(err));
|
|
cJSON_Delete(json);
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to save setting");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Updated loadBalancingCurrentLimit to: %d", currentLimit);
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
httpd_resp_sendstr(req, "Load balancing settings updated successfully");
|
|
return ESP_OK;
|
|
}
|
|
|
|
// Registro dos handlers na API HTTP
|
|
void register_loadbalancing_settings_handlers(httpd_handle_t server, void *ctx) {
|
|
// GET
|
|
httpd_uri_t get_uri = {
|
|
.uri = "/api/v1/config/loadbalancing",
|
|
.method = HTTP_GET,
|
|
.handler = loadbalancing_config_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &get_uri);
|
|
|
|
// POST
|
|
httpd_uri_t post_uri = {
|
|
.uri = "/api/v1/config/loadbalancing",
|
|
.method = HTTP_POST,
|
|
.handler = loadbalancing_config_post_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &post_uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/loadbalancing_settings_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/src/evse_settings_api.c ===
|
|
// =========================
|
|
// evse_settings_api.c
|
|
// =========================
|
|
#include "evse_settings_api.h"
|
|
#include "evse_api.h"
|
|
#include "esp_log.h"
|
|
#include "cJSON.h"
|
|
|
|
static const char *TAG = "evse_settings_api";
|
|
|
|
static esp_err_t config_settings_get_handler(httpd_req_t *req) {
|
|
httpd_resp_set_type(req, "application/json");
|
|
cJSON *config = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(config, "currentLimit", evse_get_max_charging_current());
|
|
cJSON_AddNumberToObject(config, "temperatureLimit", evse_get_temp_threshold());
|
|
const char *json_str = cJSON_Print(config);
|
|
httpd_resp_sendstr(req, json_str);
|
|
free((void *)json_str);
|
|
cJSON_Delete(config);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t config_settings_post_handler(httpd_req_t *req) {
|
|
char buf[512];
|
|
int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
|
|
if (len <= 0) {
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Empty body");
|
|
return ESP_FAIL;
|
|
}
|
|
buf[len] = '\0';
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (!json) {
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
cJSON *current = cJSON_GetObjectItem(json, "currentLimit");
|
|
if (current) evse_set_max_charging_current(current->valueint);
|
|
cJSON *temp = cJSON_GetObjectItem(json, "temperatureLimit");
|
|
if (temp) evse_set_temp_threshold(temp->valueint);
|
|
|
|
cJSON_Delete(json);
|
|
httpd_resp_sendstr(req, "Configurações atualizadas com sucesso");
|
|
return ESP_OK;
|
|
}
|
|
|
|
void register_evse_settings_handlers(httpd_handle_t server, void *ctx) {
|
|
httpd_uri_t get_uri = {
|
|
.uri = "/api/v1/config/settings",
|
|
.method = HTTP_GET,
|
|
.handler = config_settings_get_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &get_uri);
|
|
|
|
httpd_uri_t post_uri = {
|
|
.uri = "/api/v1/config/settings",
|
|
.method = HTTP_POST,
|
|
.handler = config_settings_post_handler,
|
|
.user_ctx = ctx
|
|
};
|
|
httpd_register_uri_handler(server, &post_uri);
|
|
}
|
|
|
|
// === Fim de: components/rest_api/src/evse_settings_api.c ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/dashboard_api.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "esp_http_server.h"
|
|
|
|
/**
|
|
* @brief Registra o handler da dashboard (status geral do sistema)
|
|
*/
|
|
void register_dashboard_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/rest_api/include/dashboard_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/static_file_api.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "esp_http_server.h"
|
|
|
|
/**
|
|
* @brief Registra o handler para servir arquivos estáticos da web (SPA)
|
|
*/
|
|
void register_static_file_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/rest_api/include/static_file_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/network_api.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "esp_http_server.h"
|
|
|
|
/**
|
|
* @brief Registra os handlers de configuração Wi-Fi e MQTT
|
|
*/
|
|
void register_network_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/rest_api/include/network_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/auth_api.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "esp_http_server.h"
|
|
|
|
/**
|
|
* @brief Registra os handlers de autenticação e gerenciamento de usuários
|
|
*/
|
|
void register_auth_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/rest_api/include/auth_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/loadbalancing_settings_api.h ===
|
|
// =========================
|
|
// loadbalancing_settings_api.h
|
|
// =========================
|
|
|
|
#ifndef LOADBALANCING_SETTINGS_API_H
|
|
#define LOADBALANCING_SETTINGS_API_H
|
|
|
|
#include "esp_err.h"
|
|
#include "esp_http_server.h"
|
|
|
|
// Função para registrar os manipuladores de URI para as configurações de load balancing e solar
|
|
void register_loadbalancing_settings_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#endif // LOADBALANCING_SETTINGS_API_H
|
|
|
|
// === Fim de: components/rest_api/include/loadbalancing_settings_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/rest_main.h ===
|
|
#pragma once
|
|
|
|
#include <esp_err.h>
|
|
#include <esp_vfs.h>
|
|
|
|
#define SCRATCH_BUFSIZE (10240)
|
|
|
|
typedef struct rest_server_context {
|
|
char base_path[ESP_VFS_PATH_MAX + 1];
|
|
char scratch[SCRATCH_BUFSIZE];
|
|
} rest_server_context_t;
|
|
|
|
esp_err_t rest_server_init(const char *base_path);
|
|
|
|
// === Fim de: components/rest_api/include/rest_main.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/meters_settings_api.h ===
|
|
// =========================
|
|
// meters_settings_api.h
|
|
// =========================
|
|
|
|
#ifndef METERS_SETTINGS_API_H
|
|
#define METERS_SETTINGS_API_H
|
|
|
|
#include "esp_err.h"
|
|
#include "esp_http_server.h"
|
|
|
|
// Função para registrar os manipuladores de URI para as configurações dos contadores
|
|
void register_meters_settings_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#endif // METERS_SETTINGS_API_H
|
|
|
|
// === Fim de: components/rest_api/include/meters_settings_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/ocpp_api.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "esp_http_server.h"
|
|
|
|
/**
|
|
* @brief Registra os handlers da configuração e status do OCPP
|
|
*/
|
|
void register_ocpp_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/rest_api/include/ocpp_api.h ===
|
|
|
|
|
|
// === Início de: components/rest_api/include/evse_settings_api.h ===
|
|
#pragma once
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "esp_http_server.h"
|
|
|
|
/**
|
|
* @brief Registra os handlers de configuração elétrica e limites de carregamento
|
|
*/
|
|
void register_evse_settings_handlers(httpd_handle_t server, void *ctx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
// === Fim de: components/rest_api/include/evse_settings_api.h ===
|
|
|
|
|
|
// === Início de: components/network/src/wifi_2.c ===
|
|
#include <string.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/event_groups.h"
|
|
#include "esp_log.h"
|
|
#include "esp_wifi.h"
|
|
#include "esp_event.h"
|
|
#include "esp_netif.h"
|
|
#include "esp_mac.h"
|
|
#include "nvs.h"
|
|
#include "mdns.h"
|
|
|
|
#include "wifi.h"
|
|
|
|
|
|
#include "nvs_flash.h"
|
|
#include <string.h>
|
|
|
|
#define WIFI_STORAGE_NAMESPACE "wifi_config"
|
|
|
|
|
|
|
|
#define TAG "wifi"
|
|
#define AP_SSID "plx-%02x%02x%02x"
|
|
#define MDNS_HOSTNAME "plx%02x"
|
|
|
|
#define NVS_NAMESPACE "wifi"
|
|
|
|
static nvs_handle_t nvs;
|
|
static esp_netif_t *ap_netif;
|
|
EventGroupHandle_t wifi_event_group;
|
|
|
|
//
|
|
// Event handler para modo AP
|
|
//
|
|
static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
|
|
{
|
|
if (event_base == WIFI_EVENT) {
|
|
switch (event_id) {
|
|
case WIFI_EVENT_AP_STACONNECTED: {
|
|
wifi_event_ap_staconnected_t *event = event_data;
|
|
ESP_LOGI(TAG, "STA " MACSTR " conectou, AID=%d", MAC2STR(event->mac), event->aid);
|
|
xEventGroupSetBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
|
|
break;
|
|
}
|
|
case WIFI_EVENT_AP_STADISCONNECTED: {
|
|
wifi_event_ap_stadisconnected_t *event = event_data;
|
|
ESP_LOGI(TAG, "STA " MACSTR " desconectou, AID=%d", MAC2STR(event->mac), event->aid);
|
|
xEventGroupClearBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Iniciar o AP com SSID baseado no MAC
|
|
//
|
|
void wifi_ap_start(void)
|
|
{
|
|
ESP_LOGI(TAG, "Iniciando AP");
|
|
|
|
ESP_ERROR_CHECK(esp_wifi_stop());
|
|
|
|
wifi_config_t ap_config = {
|
|
.ap = {
|
|
.ssid = "",
|
|
.ssid_len = 0,
|
|
.channel = 1,
|
|
.password = "",
|
|
.max_connection = 4,
|
|
.authmode = WIFI_AUTH_OPEN
|
|
}
|
|
};
|
|
|
|
uint8_t mac[6];
|
|
ESP_ERROR_CHECK(esp_read_mac(mac, ESP_MAC_WIFI_SOFTAP));
|
|
snprintf((char *)ap_config.ap.ssid, sizeof(ap_config.ap.ssid), AP_SSID, mac[3], mac[4], mac[5]);
|
|
|
|
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
|
|
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap_config));
|
|
ESP_ERROR_CHECK(esp_wifi_start());
|
|
|
|
xEventGroupSetBits(wifi_event_group, WIFI_AP_MODE_BIT);
|
|
}
|
|
|
|
//
|
|
// Inicializar Wi-Fi em modo AP
|
|
//
|
|
void wifi_ini(void)
|
|
{
|
|
ESP_LOGI(TAG, "Inicializando Wi-Fi (modo AP)");
|
|
|
|
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
|
|
|
|
wifi_event_group = xEventGroupCreate();
|
|
|
|
ESP_ERROR_CHECK(esp_netif_init());
|
|
/*
|
|
if (!esp_event_loop_is_running()) {
|
|
ESP_ERROR_CHECK(esp_event_loop_create_default());
|
|
}*/
|
|
|
|
ap_netif = esp_netif_create_default_wifi_ap();
|
|
|
|
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
|
|
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
|
|
|
|
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
|
|
|
|
uint8_t mac[6];
|
|
ESP_ERROR_CHECK(esp_read_mac(mac, ESP_MAC_WIFI_SOFTAP));
|
|
char hostname[16];
|
|
snprintf(hostname, sizeof(hostname), MDNS_HOSTNAME, mac[5]);
|
|
|
|
ESP_ERROR_CHECK(mdns_init());
|
|
ESP_ERROR_CHECK(mdns_hostname_set(hostname));
|
|
ESP_ERROR_CHECK(mdns_instance_name_set("EVSE Controller"));
|
|
|
|
wifi_ap_start();
|
|
}
|
|
|
|
esp_netif_t *wifi_get_ap_netif(void)
|
|
{
|
|
return ap_netif;
|
|
}
|
|
|
|
esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password) {
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
void wifi_get_ssid(char *value) {
|
|
// Your implementation here
|
|
}
|
|
|
|
void wifi_get_password(char *value) {
|
|
// Your implementation here
|
|
}
|
|
|
|
bool wifi_get_enabled(void)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// === Fim de: components/network/src/wifi_2.c ===
|
|
|
|
|
|
// === Início de: components/network/src/wifi.c ===
|
|
#include <string.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/event_groups.h"
|
|
#include "esp_log.h"
|
|
#include "esp_wifi.h"
|
|
#include "esp_event.h"
|
|
#include "esp_netif.h"
|
|
#include "esp_mac.h"
|
|
#include "nvs.h"
|
|
#include "mdns.h"
|
|
|
|
#include "wifi.h"
|
|
|
|
#define AP_SSID "plx-%02x%02x%02x"
|
|
|
|
#define MDNS_SSID "plx%02x"
|
|
|
|
#define NVS_NAMESPACE "wifi"
|
|
#define NVS_ENABLED "enabled"
|
|
#define NVS_SSID "ssid"
|
|
#define NVS_PASSWORD "password"
|
|
|
|
static const char *TAG = "wifi";
|
|
|
|
static nvs_handle_t nvs;
|
|
|
|
static esp_netif_t *sta_netif;
|
|
|
|
static esp_netif_t *ap_netif;
|
|
|
|
EventGroupHandle_t wifi_event_group;
|
|
|
|
static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
|
|
{
|
|
ESP_LOGI(TAG, "event_handler");
|
|
|
|
if (event_base == WIFI_EVENT)
|
|
{
|
|
if (event_id == WIFI_EVENT_AP_STACONNECTED)
|
|
{
|
|
ESP_LOGI(TAG, "STA connected");
|
|
wifi_event_ap_staconnected_t *event = (wifi_event_ap_staconnected_t *)event_data;
|
|
ESP_LOGI(TAG, "WiFi AP " MACSTR " join, AID=%d", MAC2STR(event->mac), event->aid);
|
|
xEventGroupClearBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
|
|
xEventGroupSetBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
|
|
}
|
|
if (event_id == WIFI_EVENT_AP_STADISCONNECTED)
|
|
{
|
|
ESP_LOGI(TAG, "AP STA disconnected");
|
|
wifi_event_ap_stadisconnected_t *event = (wifi_event_ap_stadisconnected_t *)event_data;
|
|
ESP_LOGI(TAG, "WiFi AP " MACSTR " leave, AID=%d", MAC2STR(event->mac), event->aid);
|
|
xEventGroupClearBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
|
|
xEventGroupSetBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
|
|
}
|
|
if (event_id == WIFI_EVENT_STA_DISCONNECTED)
|
|
{
|
|
ESP_LOGI(TAG, "STA disconnected");
|
|
xEventGroupClearBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
|
|
xEventGroupSetBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
|
|
esp_wifi_connect();
|
|
}
|
|
if (event_id == WIFI_EVENT_STA_START)
|
|
{
|
|
ESP_LOGI(TAG, "STA start");
|
|
esp_wifi_connect();
|
|
}
|
|
}
|
|
else if (event_base == IP_EVENT)
|
|
{
|
|
ESP_LOGI(TAG, "event_base == IP_EVENT");
|
|
|
|
if (event_id == IP_EVENT_STA_GOT_IP || event_id == IP_EVENT_GOT_IP6)
|
|
{
|
|
if (event_id == IP_EVENT_STA_GOT_IP)
|
|
{
|
|
ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
|
|
ESP_LOGI(TAG, "WiFi STA got ip: " IPSTR, IP2STR(&event->ip_info.ip));
|
|
}
|
|
else
|
|
{
|
|
ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
|
|
ESP_LOGI(TAG, "WiFi STA got ip6: " IPV6STR, IPV62STR(event->ip6_info.ip));
|
|
}
|
|
xEventGroupClearBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
|
|
xEventGroupSetBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void sta_set_config(void)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "sta_set_config");
|
|
|
|
if (wifi_get_enabled())
|
|
{
|
|
wifi_config_t wifi_config = {
|
|
.sta = {
|
|
.pmf_cfg = {
|
|
.capable = true,
|
|
.required = false}}};
|
|
wifi_get_ssid((char *)wifi_config.sta.ssid);
|
|
wifi_get_password((char *)wifi_config.sta.password);
|
|
|
|
esp_wifi_set_mode(WIFI_MODE_STA);
|
|
esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
|
|
}
|
|
}
|
|
|
|
static void ap_set_config(void)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "ap_set_config");
|
|
|
|
wifi_config_t wifi_ap_config = {
|
|
.ap = {
|
|
.max_connection = 1,
|
|
.authmode = WIFI_AUTH_OPEN}};
|
|
uint8_t mac[6];
|
|
esp_wifi_get_mac(ESP_IF_WIFI_AP, mac);
|
|
sprintf((char *)wifi_ap_config.ap.ssid, AP_SSID, mac[3], mac[4], mac[5]);
|
|
|
|
wifi_config_t wifi_sta_config = {0};
|
|
|
|
esp_wifi_set_mode(WIFI_MODE_APSTA);
|
|
esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_ap_config);
|
|
esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_sta_config);
|
|
}
|
|
|
|
static void sta_try_start(void)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "sta_try_start");
|
|
|
|
sta_set_config();
|
|
if (wifi_get_enabled())
|
|
{
|
|
ESP_LOGI(TAG, "Starting STA");
|
|
esp_wifi_start();
|
|
xEventGroupSetBits(wifi_event_group, WIFI_STA_MODE_BIT);
|
|
}
|
|
}
|
|
|
|
void wifi_ini(void)
|
|
{
|
|
|
|
|
|
ESP_LOGI(TAG, "Wifi init");
|
|
|
|
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
|
|
|
|
wifi_event_group = xEventGroupCreate();
|
|
|
|
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
|
|
|
|
ap_netif = esp_netif_create_default_wifi_ap();
|
|
sta_netif = esp_netif_create_default_wifi_sta();
|
|
|
|
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
|
|
|
|
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
|
|
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
|
|
|
|
char chargeid[6];
|
|
uint8_t mac[6];
|
|
esp_wifi_get_mac(ESP_IF_WIFI_AP, mac);
|
|
sprintf((char *)chargeid, MDNS_SSID, mac[5]);
|
|
|
|
ESP_ERROR_CHECK(mdns_init());
|
|
ESP_ERROR_CHECK(mdns_hostname_set(chargeid));
|
|
ESP_ERROR_CHECK(mdns_instance_name_set("EVSE controller"));
|
|
|
|
sta_try_start();
|
|
|
|
}
|
|
|
|
esp_netif_t *wifi_get_sta_netif(void)
|
|
{
|
|
return sta_netif;
|
|
}
|
|
|
|
esp_netif_t *wifi_get_ap_netif(void)
|
|
{
|
|
return ap_netif;
|
|
}
|
|
|
|
esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "Wifi set config");
|
|
|
|
if (enabled)
|
|
{
|
|
if (ssid == NULL || strlen(ssid) == 0)
|
|
{
|
|
size_t len = 0;
|
|
nvs_get_str(nvs, NVS_SSID, NULL, &len);
|
|
if (len <= 1)
|
|
{
|
|
ESP_LOGE(TAG, "Required SSID");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ssid != NULL && strlen(ssid) > 32)
|
|
{
|
|
ESP_LOGE(TAG, "SSID out of range");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (password != NULL && strlen(password) > 32)
|
|
{
|
|
ESP_LOGE(TAG, "Password out of range");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
nvs_set_u8(nvs, NVS_ENABLED, enabled);
|
|
if (ssid != NULL)
|
|
{
|
|
nvs_set_str(nvs, NVS_SSID, ssid);
|
|
}
|
|
if (password != NULL)
|
|
{
|
|
nvs_set_str(nvs, NVS_PASSWORD, password);
|
|
}
|
|
nvs_commit(nvs);
|
|
|
|
ESP_LOGI(TAG, "Stopping AP/STA");
|
|
xEventGroupClearBits(wifi_event_group, WIFI_AP_MODE_BIT | WIFI_STA_MODE_BIT);
|
|
esp_wifi_stop();
|
|
|
|
sta_try_start();
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "wifi_scan");
|
|
|
|
uint16_t number = WIFI_SCAN_SCAN_LIST_SIZE;
|
|
wifi_ap_record_t ap_info[WIFI_SCAN_SCAN_LIST_SIZE];
|
|
uint16_t ap_count = 0;
|
|
memset(ap_info, 0, sizeof(ap_info));
|
|
|
|
esp_wifi_scan_start(NULL, true);
|
|
esp_wifi_scan_get_ap_records(&number, ap_info);
|
|
esp_wifi_scan_get_ap_num(&ap_count);
|
|
|
|
ESP_LOGI(TAG, "wifi_scan --- %d", ap_count);
|
|
|
|
for (int i = 0; (i < WIFI_SCAN_SCAN_LIST_SIZE) && (i < ap_count); i++)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "wifi_scan ---");
|
|
|
|
strcpy(scan_aps[i].ssid, (const char *)ap_info[i].ssid);
|
|
scan_aps[i].rssi = ap_info[i].rssi;
|
|
scan_aps[i].auth = ap_info[i].authmode != WIFI_AUTH_OPEN;
|
|
}
|
|
|
|
return ap_count;
|
|
}
|
|
|
|
bool wifi_get_enabled(void)
|
|
{
|
|
uint8_t value = false;
|
|
nvs_get_u8(nvs, NVS_ENABLED, &value);
|
|
return value;
|
|
}
|
|
|
|
void wifi_get_ssid(char *value)
|
|
{
|
|
size_t len = 32;
|
|
value[0] = '\0';
|
|
nvs_get_str(nvs, NVS_SSID, value, &len);
|
|
}
|
|
|
|
void wifi_get_password(char *value)
|
|
{
|
|
size_t len = 64;
|
|
value[0] = '\0';
|
|
nvs_get_str(nvs, NVS_PASSWORD, value, &len);
|
|
}
|
|
|
|
void wifi_ap_start(void)
|
|
{
|
|
ESP_LOGI(TAG, "Starting AP");
|
|
|
|
xEventGroupClearBits(wifi_event_group, WIFI_STA_MODE_BIT);
|
|
esp_wifi_stop();
|
|
|
|
ap_set_config();
|
|
esp_wifi_start();
|
|
|
|
xEventGroupSetBits(wifi_event_group, WIFI_AP_MODE_BIT);
|
|
}
|
|
|
|
void wifi_ap_stop(void)
|
|
{
|
|
ESP_LOGI(TAG, "Stopping AP");
|
|
xEventGroupClearBits(wifi_event_group, WIFI_AP_MODE_BIT);
|
|
esp_wifi_stop();
|
|
|
|
sta_try_start();
|
|
}
|
|
|
|
bool wifi_is_ap(void)
|
|
{
|
|
wifi_mode_t mode;
|
|
esp_wifi_get_mode(&mode);
|
|
return mode == WIFI_MODE_APSTA;
|
|
}
|
|
|
|
// === Fim de: components/network/src/wifi.c ===
|
|
|
|
|
|
// === Início de: components/network/include/wifi.h ===
|
|
#ifndef WIFI_H_
|
|
#define WIFI_H_
|
|
|
|
#include <stdbool.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/event_groups.h"
|
|
#include "esp_err.h"
|
|
#include "esp_netif.h"
|
|
|
|
#define WIFI_SCAN_SCAN_LIST_SIZE 10
|
|
|
|
#define WIFI_AP_CONNECTED_BIT BIT0
|
|
#define WIFI_AP_DISCONNECTED_BIT BIT1
|
|
#define WIFI_STA_CONNECTED_BIT BIT2
|
|
#define WIFI_STA_DISCONNECTED_BIT BIT3
|
|
#define WIFI_AP_MODE_BIT BIT4
|
|
#define WIFI_STA_MODE_BIT BIT5
|
|
|
|
typedef struct
|
|
{
|
|
char ssid[32];
|
|
int rssi;
|
|
bool auth;
|
|
} wifi_scan_ap_t;
|
|
|
|
/**
|
|
* @brief WiFi event group WIFI_AP_CONNECTED_BIT | WIFI_AP_DISCONNECTED_BIT | WIFI_STA_CONNECTED_BIT | WIFI_STA_DISCONNECTED_BIT | WIFI_AP_MODE_BIT | WIFI_STA_MODE_BIT
|
|
*
|
|
*/
|
|
extern EventGroupHandle_t wifi_event_group;
|
|
|
|
/**
|
|
* @brief Initialize WiFi
|
|
*
|
|
*/
|
|
void wifi_ini(void);
|
|
|
|
/**
|
|
* @brief Return WiFi STA network interface
|
|
*
|
|
* @return esp_netif_t*
|
|
*/
|
|
esp_netif_t* wifi_get_sta_netif(void);
|
|
|
|
/**
|
|
* @brief Return WiFi AP network interface
|
|
*
|
|
* @return esp_netif_t*
|
|
*/
|
|
esp_netif_t* wifi_get_ap_netif(void);
|
|
|
|
/**
|
|
* @brief Set WiFi config
|
|
*
|
|
* @param enabled
|
|
* @param ssid NULL value will be skiped
|
|
* @param password NULL value will be skiped
|
|
* @return esp_err_t
|
|
*/
|
|
esp_err_t wifi_set_config(bool enabled, const char* ssid, const char* password);
|
|
|
|
/**
|
|
* @brief Get WiFi STA enabled, stored in NVS
|
|
*
|
|
* @return true
|
|
* @return false
|
|
*/
|
|
bool wifi_get_enabled(void);
|
|
|
|
/**
|
|
* @brief Scan for AP
|
|
*
|
|
* @param scan_aps array with length WIFI_SCAN_SCAN_LIST_SIZE
|
|
* @return uint16_t number of available AP
|
|
*/
|
|
uint16_t wifi_scan(wifi_scan_ap_t *scan_aps);
|
|
|
|
/**
|
|
* @brief Get WiFi STA ssid, string length 32, stored in NVS
|
|
*
|
|
* @param value
|
|
*/
|
|
void wifi_get_ssid(char* value);
|
|
|
|
/**
|
|
* @brief Get WiFi STA password, string length 32, stored in NVS
|
|
*
|
|
* @param value
|
|
*/
|
|
void wifi_get_password(char* value);
|
|
|
|
/**
|
|
* @brief Start WiFi AP mode
|
|
*
|
|
*/
|
|
void wifi_ap_start(void);
|
|
|
|
/**
|
|
* @brief Stop WiFi AP mode
|
|
*
|
|
*/
|
|
void wifi_ap_stop(void);
|
|
|
|
#endif /* WIFI_H_ */
|
|
|
|
// === Fim de: components/network/include/wifi.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/ac_relay.c ===
|
|
#include "esp_log.h"
|
|
#include "driver/gpio.h"
|
|
|
|
#include "ac_relay.h"
|
|
#include "board_config.h"
|
|
|
|
static const char* TAG = "ac_relay";
|
|
|
|
/**
|
|
* @brief Initialize the AC relay GPIO.
|
|
*
|
|
* Configures the specified GPIO pin as an output and sets its initial state to OFF (low).
|
|
*/
|
|
void ac_relay_init(void)
|
|
{
|
|
gpio_config_t conf = {
|
|
.pin_bit_mask = BIT64(board_config.ac_relay_gpio),
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE, ///< Disabled unless required
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE
|
|
};
|
|
|
|
esp_err_t ret = gpio_config(&conf);
|
|
if (ret != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to configure GPIO (error: %s)", esp_err_to_name(ret));
|
|
return;
|
|
}
|
|
|
|
gpio_set_level(board_config.ac_relay_gpio, false); ///< Ensure relay starts OFF
|
|
ESP_LOGI(TAG, "AC relay initialized. Pin: %d", board_config.ac_relay_gpio);
|
|
}
|
|
|
|
/**
|
|
* @brief Set the state of the AC relay.
|
|
*
|
|
* @param state True to turn the relay ON, False to turn it OFF.
|
|
*/
|
|
void ac_relay_set_state(bool state)
|
|
{
|
|
ESP_LOGI(TAG, "Setting AC relay state: Pin: %d, State: %d", board_config.ac_relay_gpio, state);
|
|
|
|
esp_err_t ret = gpio_set_level(board_config.ac_relay_gpio, state);
|
|
if (ret != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to set GPIO level (error: %s)", esp_err_to_name(ret));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Get the current state of the AC relay.
|
|
*
|
|
* @return true if the relay is ON, false if OFF.
|
|
*/
|
|
bool ac_relay_get_state(void)
|
|
{
|
|
int level = gpio_get_level(board_config.ac_relay_gpio);
|
|
ESP_LOGD(TAG, "Current AC relay state: Pin: %d, State: %d", board_config.ac_relay_gpio, level);
|
|
return level;
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/ac_relay.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/ntc_sensor.c ===
|
|
#include <sys/param.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include "freertos/task.h"
|
|
#include "esp_log.h"
|
|
#include "ntc_sensor.h"
|
|
#include "ntc_driver.h"
|
|
|
|
#include "adc.h"
|
|
|
|
static const char *TAG = "temp_sensor";
|
|
|
|
#define MEASURE_PERIOD 15000 // 10s
|
|
|
|
static float temp = 0.0;
|
|
|
|
static ntc_device_handle_t ntc = NULL;
|
|
|
|
static portMUX_TYPE temp_mux = portMUX_INITIALIZER_UNLOCKED;
|
|
|
|
static void ntc_sensor_task_func(void *param) {
|
|
float t;
|
|
while (true) {
|
|
if (ntc_dev_get_temperature(ntc, &t) == ESP_OK) {
|
|
portENTER_CRITICAL(&temp_mux);
|
|
temp = t;
|
|
portEXIT_CRITICAL(&temp_mux);
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(MEASURE_PERIOD));
|
|
}
|
|
}
|
|
|
|
float ntc_temp_sensor(void) {
|
|
float t;
|
|
portENTER_CRITICAL(&temp_mux);
|
|
t = temp;
|
|
portEXIT_CRITICAL(&temp_mux);
|
|
return t;
|
|
}
|
|
|
|
void ntc_sensor_init(void)
|
|
{
|
|
|
|
ESP_LOGI(TAG, "ntc_sensor_init");
|
|
|
|
// Select the NTC sensor and initialize the hardware parameters
|
|
ntc_config_t ntc_config = {
|
|
.b_value = 3950,
|
|
.r25_ohm = 10000,
|
|
.fixed_ohm = 4700,
|
|
.vdd_mv = 3300,
|
|
.circuit_mode = CIRCUIT_MODE_NTC_GND,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.channel = ADC_CHANNEL_0,
|
|
.unit = ADC_UNIT_1};
|
|
|
|
// Create the NTC Driver and Init ADC
|
|
// ntc_device_handle_t ntc = NULL;
|
|
// adc_oneshot_unit_handle_t adc_handle = NULL;
|
|
ESP_ERROR_CHECK(ntc_dev_create(&ntc_config, &ntc, &adc_handle));
|
|
ESP_ERROR_CHECK(ntc_dev_get_adc_handle(ntc, &adc_handle));
|
|
|
|
xTaskCreate(ntc_sensor_task_func, "ntc_sensor_task", 5 * 1024, NULL, 3, NULL);
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/ntc_sensor.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/proximity.c ===
|
|
#include "esp_log.h"
|
|
|
|
#include "proximity.h"
|
|
#include "board_config.h"
|
|
#include "adc.h"
|
|
|
|
static const char *TAG = "proximity";
|
|
|
|
void proximity_init(void)
|
|
{
|
|
if (board_config.proximity)
|
|
{
|
|
adc_oneshot_chan_cfg_t config = {
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
.atten = ADC_ATTEN_DB_12};
|
|
ESP_ERROR_CHECK(adc_oneshot_config_channel(adc_handle, board_config.proximity_adc_channel, &config));
|
|
}
|
|
}
|
|
|
|
uint8_t proximity_get_max_current(void)
|
|
{
|
|
int voltage;
|
|
adc_oneshot_read(adc_handle, board_config.proximity_adc_channel, &voltage);
|
|
adc_cali_raw_to_voltage(adc_cali_handle, voltage, &voltage);
|
|
|
|
ESP_LOGI(TAG, "Measured: %dmV", voltage);
|
|
|
|
uint8_t current;
|
|
|
|
if (voltage >= board_config.proximity_down_threshold_8)
|
|
{
|
|
current = 8;
|
|
}
|
|
else if (voltage >= board_config.proximity_down_threshold_10)
|
|
{
|
|
current = 10;
|
|
}
|
|
|
|
else if (voltage >= board_config.proximity_down_threshold_13)
|
|
{
|
|
current = 13;
|
|
}
|
|
else if (voltage >= board_config.proximity_down_threshold_20)
|
|
{
|
|
current = 20;
|
|
}
|
|
|
|
else if (voltage >= board_config.proximity_down_threshold_25)
|
|
{
|
|
current = 25;
|
|
}
|
|
else if (voltage >= board_config.proximity_down_threshold_32)
|
|
{
|
|
current = 32;
|
|
}
|
|
else
|
|
{
|
|
current = 32;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Max current: %dA", current);
|
|
|
|
return current;
|
|
}
|
|
// === Fim de: components/peripherals/src/proximity.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/buzzer.c ===
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/queue.h"
|
|
#include "driver/gpio.h"
|
|
#include "board_config.h"
|
|
#include "buzzer.h"
|
|
#include "evse_api.h"
|
|
|
|
static gpio_num_t buzzer_gpio = GPIO_NUM_NC;
|
|
static evse_state_t last_buzzer_state = -1;
|
|
static QueueHandle_t buzzer_queue = NULL;
|
|
|
|
void buzzer_on(void) {
|
|
if (buzzer_gpio != GPIO_NUM_NC)
|
|
gpio_set_level(buzzer_gpio, 1);
|
|
}
|
|
|
|
void buzzer_off(void) {
|
|
if (buzzer_gpio != GPIO_NUM_NC)
|
|
gpio_set_level(buzzer_gpio, 0);
|
|
}
|
|
|
|
// ----------------------
|
|
// Padrões de Buzzer
|
|
// ----------------------
|
|
|
|
typedef struct {
|
|
uint16_t on_ms;
|
|
uint16_t off_ms;
|
|
} buzzer_pattern_step_t;
|
|
|
|
typedef enum {
|
|
BUZZER_PATTERN_NONE = 0,
|
|
BUZZER_PATTERN_PLUGGED,
|
|
BUZZER_PATTERN_UNPLUGGED,
|
|
BUZZER_PATTERN_CHARGING,
|
|
} buzzer_pattern_id_t;
|
|
|
|
static const buzzer_pattern_step_t pattern_plugged[] = {
|
|
{100, 100}, {200, 0}
|
|
};
|
|
|
|
static const buzzer_pattern_step_t pattern_unplugged[] = {
|
|
{150, 150}, {150, 150}, {150, 0}
|
|
};
|
|
|
|
static const buzzer_pattern_step_t pattern_charging[] = {
|
|
{80, 150}, {100, 120}, {120, 100}, {140, 0}
|
|
};
|
|
|
|
// ----------------------
|
|
// Executor de padrões
|
|
// ----------------------
|
|
|
|
static void buzzer_execute_pattern(buzzer_pattern_id_t pattern_id) {
|
|
const buzzer_pattern_step_t *pattern = NULL;
|
|
size_t length = 0;
|
|
|
|
switch (pattern_id) {
|
|
case BUZZER_PATTERN_PLUGGED:
|
|
pattern = pattern_plugged;
|
|
length = sizeof(pattern_plugged) / sizeof(pattern_plugged[0]);
|
|
break;
|
|
case BUZZER_PATTERN_UNPLUGGED:
|
|
pattern = pattern_unplugged;
|
|
length = sizeof(pattern_unplugged) / sizeof(pattern_unplugged[0]);
|
|
break;
|
|
case BUZZER_PATTERN_CHARGING:
|
|
pattern = pattern_charging;
|
|
length = sizeof(pattern_charging) / sizeof(pattern_charging[0]);
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < length; i++) {
|
|
buzzer_on();
|
|
vTaskDelay(pdMS_TO_TICKS(pattern[i].on_ms));
|
|
buzzer_off();
|
|
if (pattern[i].off_ms > 0)
|
|
vTaskDelay(pdMS_TO_TICKS(pattern[i].off_ms));
|
|
}
|
|
}
|
|
|
|
// ----------------------
|
|
// Task que toca o buzzer
|
|
// ----------------------
|
|
|
|
static void buzzer_worker_task(void *arg) {
|
|
buzzer_pattern_id_t pattern_id;
|
|
|
|
while (true) {
|
|
if (xQueueReceive(buzzer_queue, &pattern_id, portMAX_DELAY)) {
|
|
//buzzer_execute_pattern(pattern_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------
|
|
// Task de monitoramento
|
|
// ----------------------
|
|
|
|
static void buzzer_monitor_task(void *arg) {
|
|
while (true) {
|
|
evse_state_t current = evse_get_state();
|
|
|
|
if (current != last_buzzer_state) {
|
|
buzzer_pattern_id_t pattern_id = BUZZER_PATTERN_NONE;
|
|
|
|
switch (current) {
|
|
case EVSE_STATE_A:
|
|
if (last_buzzer_state != EVSE_STATE_A)
|
|
pattern_id = BUZZER_PATTERN_UNPLUGGED;
|
|
break;
|
|
case EVSE_STATE_B1:
|
|
case EVSE_STATE_B2:
|
|
if (last_buzzer_state != EVSE_STATE_B1 && last_buzzer_state != EVSE_STATE_B2)
|
|
pattern_id = BUZZER_PATTERN_PLUGGED;
|
|
break;
|
|
case EVSE_STATE_C2:
|
|
case EVSE_STATE_D2:
|
|
if (last_buzzer_state != EVSE_STATE_C2 && last_buzzer_state != EVSE_STATE_D2)
|
|
pattern_id = BUZZER_PATTERN_CHARGING;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (pattern_id != BUZZER_PATTERN_NONE) {
|
|
xQueueSend(buzzer_queue, &pattern_id, 0); // Não bloqueia
|
|
}
|
|
|
|
last_buzzer_state = current;
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
}
|
|
}
|
|
|
|
// ----------------------
|
|
// Inicialização
|
|
// ----------------------
|
|
|
|
void buzzer_init(void) {
|
|
if (board_config.buzzer) {
|
|
buzzer_gpio = board_config.buzzer_gpio;
|
|
|
|
gpio_config_t io_conf = {
|
|
.pin_bit_mask = BIT64(buzzer_gpio),
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
.pull_down_en = GPIO_PULLDOWN_ENABLE,
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE
|
|
};
|
|
gpio_config(&io_conf);
|
|
gpio_set_level(buzzer_gpio, 0);
|
|
}
|
|
|
|
buzzer_queue = xQueueCreate(4, sizeof(buzzer_pattern_id_t));
|
|
|
|
xTaskCreate(buzzer_monitor_task, "buzzer_monitor", 2048, NULL, 3, NULL);
|
|
xTaskCreate(buzzer_worker_task, "buzzer_worker", 2048, NULL, 3, NULL);
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/buzzer.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/ds18x20.h ===
|
|
/*
|
|
* Copyright (c) 2016 Grzegorz Hetman <ghetman@gmail.com>
|
|
* Copyright (c) 2016 Alex Stewart <foogod@gmail.com>
|
|
* Copyright (c) 2018 Ruslan V. Uss <unclerus@gmail.com>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the copyright holder nor the names of itscontributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef _DS18X20_H
|
|
#define _DS18X20_H
|
|
|
|
#include <esp_err.h>
|
|
#include "onewire.h"
|
|
|
|
typedef onewire_addr_t ds18x20_addr_t;
|
|
|
|
/** An address value which can be used to indicate "any device on the bus" */
|
|
#define DS18X20_ANY ONEWIRE_NONE
|
|
|
|
/** Family ID (lower address byte) of DS18B20 sensors */
|
|
#define DS18B20_FAMILY_ID 0x28
|
|
|
|
/** Family ID (lower address byte) of DS18S20 sensors */
|
|
#define DS18S20_FAMILY_ID 0x10
|
|
|
|
/**
|
|
* @brief Find the addresses of all ds18x20 devices on the bus.
|
|
*
|
|
* Scans the bus for all devices and places their addresses in the supplied
|
|
* array. If there are more than `addr_count` devices on the bus, only the
|
|
* first `addr_count` are recorded.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 bus
|
|
* @param addr_list A pointer to an array of ::ds18x20_addr_t values.
|
|
* This will be populated with the addresses of the found
|
|
* devices.
|
|
* @param addr_count Number of slots in the `addr_list` array. At most this
|
|
* many addresses will be returned.
|
|
* @param found The number of devices found. Note that this may be less
|
|
* than, equal to, or more than `addr_count`, depending on
|
|
* how many ds18x20 devices are attached to the bus.
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18x20_scan_devices(gpio_num_t pin, ds18x20_addr_t *addr_list, size_t addr_count, size_t *found);
|
|
|
|
/**
|
|
* @brief Tell one or more sensors to perform a temperature measurement and
|
|
* conversion (CONVERT_T) operation.
|
|
*
|
|
* This operation can take up to 750ms to complete.
|
|
*
|
|
* If `wait=true`, this routine will automatically drive the pin high for the
|
|
* necessary 750ms after issuing the command to ensure parasitically-powered
|
|
* devices have enough power to perform the conversion operation (for
|
|
* non-parasitically-powered devices, this is not necessary but does not
|
|
* hurt). If `wait=false`, this routine will drive the pin high, but will
|
|
* then return immediately. It is up to the caller to wait the requisite time
|
|
* and then depower the bus using onewire_depower() or by issuing another
|
|
* command once conversion is done.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device on the bus. This can be set
|
|
* to ::DS18X20_ANY to send the command to all devices on the bus
|
|
* at the same time.
|
|
* @param wait Whether to wait for the necessary 750ms for the ds18x20 to
|
|
* finish performing the conversion before returning to the
|
|
* caller (You will normally want to do this).
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18x20_measure(gpio_num_t pin, ds18x20_addr_t addr, bool wait);
|
|
|
|
/**
|
|
* @brief Read the value from the last CONVERT_T operation.
|
|
*
|
|
* This should be called after ds18x20_measure() to fetch the result of the
|
|
* temperature measurement.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param temperature The temperature in degrees Celsius
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18x20_read_temperature(gpio_num_t pin, ds18x20_addr_t addr, int16_t *temperature);
|
|
|
|
/**
|
|
* @brief Read the value from the last CONVERT_T operation (ds18b20 version).
|
|
*
|
|
* This should be called after ds18x20_measure() to fetch the result of the
|
|
* temperature measurement.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param temperature The temperature in degrees Celsius
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18b20_read_temperature(gpio_num_t pin, ds18x20_addr_t addr, int16_t *temperature);
|
|
|
|
/**
|
|
* @brief Read the value from the last CONVERT_T operation (ds18s20 version).
|
|
*
|
|
* This should be called after ds18x20_measure() to fetch the result of the
|
|
* temperature measurement.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param temperature The temperature in degrees Celsius
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18s20_read_temperature(gpio_num_t pin, ds18x20_addr_t addr, int16_t *temperature);
|
|
|
|
/**
|
|
* @brief Read the value from the last CONVERT_T operation for multiple devices.
|
|
*
|
|
* This should be called after ds18x20_measure() to fetch the result of the
|
|
* temperature measurement.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 bus
|
|
* @param addr_list A list of addresses for devices to read.
|
|
* @param addr_count The number of entries in `addr_list`.
|
|
* @param result_list An array of int16_ts to hold the returned temperature
|
|
* values. It should have at least `addr_count` entries.
|
|
*
|
|
* @returns `ESP_OK` if all temperatures were fetched successfully
|
|
*/
|
|
esp_err_t ds18x20_read_temp_multi(gpio_num_t pin, ds18x20_addr_t *addr_list, size_t addr_count, int16_t *result_list);
|
|
|
|
/** Perform a ds18x20_measure() followed by ds18s20_read_temperature()
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18s20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param temperature The temperature in degrees Celsius
|
|
*/
|
|
esp_err_t ds18s20_measure_and_read(gpio_num_t pin, ds18x20_addr_t addr, int16_t *temperature);
|
|
|
|
/** Perform a ds18x20_measure() followed by ds18b20_read_temperature()
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param temperature The temperature in degrees Celsius
|
|
*/
|
|
esp_err_t ds18b20_measure_and_read(gpio_num_t pin, ds18x20_addr_t addr, int16_t *temperature);
|
|
|
|
/** Perform a ds18x20_measure() followed by ds18x20_read_temperature()
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param temperature The temperature in degrees Celsius
|
|
*/
|
|
esp_err_t ds18x20_measure_and_read(gpio_num_t pin, ds18x20_addr_t addr, int16_t *temperature);
|
|
|
|
/**
|
|
* @brief Perform a ds18x20_measure() followed by ds18x20_read_temp_multi()
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 bus
|
|
* @param addr_list A list of addresses for devices to read.
|
|
* @param addr_count The number of entries in `addr_list`.
|
|
* @param result_list An array of int16_ts to hold the returned temperature
|
|
* values. It should have at least `addr_count` entries.
|
|
*
|
|
* @returns `ESP_OK` if all temperatures were fetched successfully
|
|
*/
|
|
esp_err_t ds18x20_measure_and_read_multi(gpio_num_t pin, ds18x20_addr_t *addr_list, size_t addr_count, int16_t *result_list);
|
|
|
|
/**
|
|
* @brief Read the scratchpad data for a particular ds18x20 device.
|
|
*
|
|
* This is not generally necessary to do directly. It is done automatically
|
|
* as part of ds18x20_read_temperature().
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to read. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param buffer An 8-byte buffer to hold the read data.
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18x20_read_scratchpad(gpio_num_t pin, ds18x20_addr_t addr, uint8_t *buffer);
|
|
|
|
/**
|
|
* @brief Write the scratchpad data for a particular ds18x20 device.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to write. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
* @param buffer An 3-byte buffer to hold the data to write
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18x20_write_scratchpad(gpio_num_t pin, ds18x20_addr_t addr, uint8_t *buffer);
|
|
|
|
/**
|
|
* @brief Issue the copy scratchpad command, copying current scratchpad to
|
|
* EEPROM.
|
|
*
|
|
* @param pin The GPIO pin connected to the ds18x20 device
|
|
* @param addr The 64-bit address of the device to command. This can be set
|
|
* to ::DS18X20_ANY to read any device on the bus (but note
|
|
* that this will only work if there is exactly one device
|
|
* connected, or they will corrupt each others' transmissions)
|
|
*
|
|
* @returns `ESP_OK` if the command was successfully issued
|
|
*/
|
|
esp_err_t ds18x20_copy_scratchpad(gpio_num_t pin, ds18x20_addr_t addr);
|
|
|
|
|
|
#endif /* _DS18X20_H */
|
|
// === Fim de: components/peripherals/src/ds18x20.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/socket_lock.c ===
|
|
#include <string.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/semphr.h"
|
|
#include "freertos/timers.h"
|
|
#include "esp_log.h"
|
|
#include "driver/gpio.h"
|
|
#include "nvs.h"
|
|
|
|
#include "socket_lock.h"
|
|
#include "board_config.h"
|
|
|
|
#define NVS_NAMESPACE "socket_lock"
|
|
#define NVS_OPERATING_TIME "op_time"
|
|
#define NVS_BREAK_TIME "break_time"
|
|
#define NVS_RETRY_COUNT "retry_count"
|
|
#define NVS_DETECTION_HIGH "detect_hi"
|
|
|
|
#define OPERATING_TIME_MIN 100
|
|
#define OPERATING_TIME_MAX 1000
|
|
#define LOCK_DELAY 500
|
|
|
|
#define LOCK_BIT BIT0
|
|
#define UNLOCK_BIT BIT1
|
|
#define REPEAT_LOCK_BIT BIT2
|
|
#define REPEAT_UNLOCK_BIT BIT3
|
|
|
|
static const char* TAG = "socket_lock";
|
|
|
|
static nvs_handle_t nvs;
|
|
|
|
static uint16_t operating_time = 300;
|
|
|
|
static uint16_t break_time = 1000;
|
|
|
|
static bool detection_high;
|
|
|
|
static uint8_t retry_count = 5;
|
|
|
|
static socket_lock_status_t status;
|
|
|
|
static TaskHandle_t socket_lock_task;
|
|
|
|
static bool is_locked(void)
|
|
{
|
|
gpio_set_level(board_config.socket_lock_a_gpio, 1);
|
|
gpio_set_level(board_config.socket_lock_b_gpio, 1);
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(board_config.socket_lock_detection_delay));
|
|
|
|
return gpio_get_level(board_config.socket_lock_detection_gpio) == detection_high;
|
|
}
|
|
|
|
bool socket_lock_is_locked_state(void)
|
|
{
|
|
return is_locked();
|
|
}
|
|
|
|
static void socket_lock_task_func(void* param)
|
|
{
|
|
uint32_t notification;
|
|
|
|
TickType_t previous_tick = 0;
|
|
uint8_t attempt = 0;
|
|
|
|
while (true) {
|
|
if (xTaskNotifyWait(0x00, 0xff, ¬ification, portMAX_DELAY)) {
|
|
if (notification & (LOCK_BIT | UNLOCK_BIT)) {
|
|
attempt = retry_count;
|
|
}
|
|
|
|
if (notification & (UNLOCK_BIT | REPEAT_UNLOCK_BIT)) {
|
|
gpio_set_level(board_config.socket_lock_a_gpio, 0);
|
|
gpio_set_level(board_config.socket_lock_b_gpio, 1);
|
|
vTaskDelay(pdMS_TO_TICKS(operating_time));
|
|
|
|
if (!is_locked()) {
|
|
ESP_LOGI(TAG, "Unlock OK");
|
|
status = SOCKED_LOCK_STATUS_IDLE;
|
|
} else {
|
|
if (attempt > 1) {
|
|
ESP_LOGW(TAG, "Not unlocked yet, repeating...");
|
|
attempt--;
|
|
xTaskNotify(socket_lock_task, REPEAT_UNLOCK_BIT, eSetBits);
|
|
} else {
|
|
ESP_LOGE(TAG, "Not unlocked");
|
|
status = SOCKED_LOCK_STATUS_UNLOCKING_FAIL;
|
|
}
|
|
}
|
|
|
|
gpio_set_level(board_config.socket_lock_a_gpio, 0);
|
|
gpio_set_level(board_config.socket_lock_b_gpio, 0);
|
|
} else if (notification & (LOCK_BIT | REPEAT_LOCK_BIT)) {
|
|
if (notification & LOCK_BIT) {
|
|
vTaskDelay(pdMS_TO_TICKS(LOCK_DELAY)); //delay before first lock attempt
|
|
}
|
|
gpio_set_level(board_config.socket_lock_a_gpio, 1);
|
|
gpio_set_level(board_config.socket_lock_b_gpio, 0);
|
|
vTaskDelay(pdMS_TO_TICKS(operating_time));
|
|
|
|
if (is_locked()) {
|
|
ESP_LOGI(TAG, "Lock OK");
|
|
status = SOCKED_LOCK_STATUS_IDLE;
|
|
} else {
|
|
if (attempt > 1) {
|
|
ESP_LOGW(TAG, "Not locked yet, repeating...");
|
|
attempt--;
|
|
xTaskNotify(socket_lock_task, REPEAT_LOCK_BIT, eSetBits);
|
|
} else {
|
|
ESP_LOGE(TAG, "Not locked");
|
|
status = SOCKED_LOCK_STATUS_LOCKING_FAIL;
|
|
}
|
|
}
|
|
|
|
gpio_set_level(board_config.socket_lock_a_gpio, 0);
|
|
gpio_set_level(board_config.socket_lock_b_gpio, 0);
|
|
}
|
|
|
|
TickType_t delay_tick = xTaskGetTickCount() - previous_tick;
|
|
if (delay_tick < pdMS_TO_TICKS(break_time)) {
|
|
vTaskDelay(pdMS_TO_TICKS(break_time) - delay_tick);
|
|
}
|
|
previous_tick = xTaskGetTickCount();
|
|
}
|
|
}
|
|
}
|
|
|
|
void socket_lock_init(void)
|
|
{
|
|
if (board_config.socket_lock) {
|
|
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
|
|
|
|
nvs_get_u16(nvs, NVS_OPERATING_TIME, &operating_time);
|
|
|
|
nvs_get_u16(nvs, NVS_BREAK_TIME, &break_time);
|
|
|
|
nvs_get_u8(nvs, NVS_RETRY_COUNT, &retry_count);
|
|
|
|
uint8_t u8;
|
|
if (nvs_get_u8(nvs, NVS_DETECTION_HIGH, &u8) == ESP_OK) {
|
|
detection_high = u8;
|
|
}
|
|
|
|
gpio_config_t io_conf = {};
|
|
|
|
io_conf.mode = GPIO_MODE_OUTPUT;
|
|
io_conf.pin_bit_mask = BIT64(board_config.socket_lock_a_gpio) | BIT64(board_config.socket_lock_b_gpio);
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
|
|
io_conf.mode = GPIO_MODE_INPUT;
|
|
io_conf.pin_bit_mask = BIT64(board_config.socket_lock_detection_gpio);
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
|
|
xTaskCreate(socket_lock_task_func, "socket_lock_task", 2 * 1024, NULL, 10, &socket_lock_task);
|
|
}
|
|
}
|
|
|
|
bool socket_lock_is_detection_high(void)
|
|
{
|
|
return detection_high;
|
|
}
|
|
|
|
void socket_lock_set_detection_high(bool _detection_high)
|
|
{
|
|
detection_high = _detection_high;
|
|
|
|
nvs_set_u8(nvs, NVS_DETECTION_HIGH, detection_high);
|
|
nvs_commit(nvs);
|
|
}
|
|
|
|
uint16_t socket_lock_get_operating_time(void)
|
|
{
|
|
return operating_time;
|
|
}
|
|
|
|
esp_err_t socket_lock_set_operating_time(uint16_t _operating_time)
|
|
{
|
|
if (_operating_time < OPERATING_TIME_MIN || _operating_time > OPERATING_TIME_MAX) {
|
|
ESP_LOGE(TAG, "Operating time out of range");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
operating_time = _operating_time;
|
|
nvs_set_u16(nvs, NVS_OPERATING_TIME, operating_time);
|
|
nvs_commit(nvs);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
uint8_t socket_lock_get_retry_count(void)
|
|
{
|
|
return retry_count;
|
|
}
|
|
|
|
void socket_lock_set_retry_count(uint8_t _retry_count)
|
|
{
|
|
retry_count = _retry_count;
|
|
nvs_set_u8(nvs, NVS_RETRY_COUNT, retry_count);
|
|
nvs_commit(nvs);
|
|
}
|
|
|
|
uint16_t socket_lock_get_break_time(void)
|
|
{
|
|
return break_time;
|
|
}
|
|
|
|
esp_err_t socket_lock_set_break_time(uint16_t _break_time)
|
|
{
|
|
if (_break_time < board_config.socket_lock_min_break_time) {
|
|
ESP_LOGE(TAG, "Operating time out of range");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
break_time = _break_time;
|
|
nvs_set_u16(nvs, NVS_BREAK_TIME, break_time);
|
|
nvs_commit(nvs);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
void socket_lock_set_locked(bool locked)
|
|
{
|
|
ESP_LOGI(TAG, "Set locked %d", locked);
|
|
|
|
xTaskNotify(socket_lock_task, locked ? LOCK_BIT : UNLOCK_BIT, eSetBits);
|
|
status = SOCKED_LOCK_STATUS_OPERATING;
|
|
}
|
|
|
|
socket_lock_status_t socket_lock_get_status(void)
|
|
{
|
|
return status;
|
|
}
|
|
// === Fim de: components/peripherals/src/socket_lock.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/temp_sensor.c ===
|
|
#include <sys/param.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include "freertos/task.h"
|
|
#include "esp_log.h"
|
|
#include "driver/gpio.h"
|
|
|
|
#include "temp_sensor.h"
|
|
#include "lm75a.h"
|
|
|
|
#define MAX_SENSORS 5
|
|
#define MEASURE_PERIOD 10000 // 10s
|
|
#define MEASURE_ERR_THRESHOLD 3
|
|
|
|
static const char *TAG = "temp_sensor";
|
|
|
|
static uint8_t sensor_count = 0;
|
|
|
|
static int16_t low_temp = 0;
|
|
|
|
static int high_temp = 0;
|
|
|
|
static uint8_t measure_err_count = 0;
|
|
|
|
static void temp_sensor_task_func(void *param)
|
|
{
|
|
while (true)
|
|
{
|
|
high_temp = lm75a_read_temperature(0);
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(MEASURE_PERIOD));
|
|
}
|
|
}
|
|
|
|
void temp_sensor_init(void)
|
|
{
|
|
|
|
ESP_LOGW(TAG, "temp_sensor_init");
|
|
|
|
lm75a_init();
|
|
|
|
xTaskCreate(temp_sensor_task_func, "temp_sensor_task", 5 * 1024, NULL, 5, NULL);
|
|
}
|
|
|
|
uint8_t temp_sensor_get_count(void)
|
|
{
|
|
return sensor_count;
|
|
}
|
|
|
|
int16_t temp_sensor_get_low(void)
|
|
{
|
|
return low_temp;
|
|
}
|
|
|
|
int temp_sensor_get_high(void)
|
|
{
|
|
return high_temp;
|
|
}
|
|
|
|
bool temp_sensor_is_error(void)
|
|
{
|
|
return sensor_count == 0 || measure_err_count > MEASURE_ERR_THRESHOLD;
|
|
}
|
|
// === Fim de: components/peripherals/src/temp_sensor.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/aux_io.c ===
|
|
#include <string.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/semphr.h"
|
|
#include "freertos/task.h"
|
|
#include "esp_log.h"
|
|
#include "driver/gpio.h"
|
|
#include "nvs.h"
|
|
|
|
#include "aux_io.h"
|
|
#include "board_config.h"
|
|
#include "adc.h"
|
|
|
|
#define MAX_AUX_IN 4
|
|
#define MAX_AUX_OUT 4
|
|
#define MAX_AUX_AIN 4
|
|
|
|
//static const char* TAG = "aux";
|
|
|
|
static int aux_in_count = 0;
|
|
static int aux_out_count = 0;
|
|
static int aux_ain_count = 0;
|
|
|
|
static struct aux_gpio_s
|
|
{
|
|
gpio_num_t gpio;
|
|
const char* name;
|
|
} aux_in[MAX_AUX_IN], aux_out[MAX_AUX_OUT];
|
|
|
|
static struct aux_adc_s
|
|
{
|
|
adc_channel_t adc;
|
|
const char* name;
|
|
} aux_ain[MAX_AUX_AIN];
|
|
|
|
|
|
void aux_init(void)
|
|
{
|
|
// IN
|
|
|
|
gpio_config_t io_conf = {
|
|
.mode = GPIO_MODE_INPUT,
|
|
.pull_up_en = GPIO_PULLDOWN_DISABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
.pin_bit_mask = 0
|
|
};
|
|
|
|
if (board_config.aux_in_1) {
|
|
aux_in[aux_in_count].gpio = board_config.aux_in_1_gpio;
|
|
aux_in[aux_in_count].name = board_config.aux_in_1_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_in_1_gpio);
|
|
aux_in_count++;
|
|
}
|
|
|
|
if (board_config.aux_in_2) {
|
|
aux_in[aux_in_count].gpio = board_config.aux_in_2_gpio;
|
|
aux_in[aux_in_count].name = board_config.aux_in_2_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_in_2_gpio);
|
|
aux_in_count++;
|
|
}
|
|
|
|
if (board_config.aux_in_3) {
|
|
aux_in[aux_in_count].gpio = board_config.aux_in_3_gpio;
|
|
aux_in[aux_in_count].name = board_config.aux_in_3_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_in_3_gpio);
|
|
aux_in_count++;
|
|
}
|
|
|
|
if (board_config.aux_in_4) {
|
|
aux_in[aux_in_count].gpio = board_config.aux_in_4_gpio;
|
|
aux_in[aux_in_count].name = board_config.aux_in_4_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_in_4_gpio);
|
|
aux_in_count++;
|
|
}
|
|
|
|
if (io_conf.pin_bit_mask > 0) {
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
}
|
|
|
|
// OUT
|
|
|
|
io_conf.mode = GPIO_MODE_OUTPUT;
|
|
io_conf.pin_bit_mask = 0;
|
|
|
|
if (board_config.aux_out_1) {
|
|
aux_out[aux_out_count].gpio = board_config.aux_out_1_gpio;
|
|
aux_out[aux_out_count].name = board_config.aux_out_1_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_out_1_gpio);
|
|
aux_out_count++;
|
|
}
|
|
|
|
if (board_config.aux_out_2) {
|
|
aux_out[aux_out_count].gpio = board_config.aux_out_2_gpio;
|
|
aux_out[aux_out_count].name = board_config.aux_out_2_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_out_2_gpio);
|
|
aux_out_count++;
|
|
}
|
|
|
|
if (board_config.aux_out_3) {
|
|
aux_out[aux_out_count].gpio = board_config.aux_out_3_gpio;
|
|
aux_out[aux_out_count].name = board_config.aux_out_3_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_out_3_gpio);
|
|
aux_out_count++;
|
|
}
|
|
|
|
if (board_config.aux_out_4) {
|
|
aux_out[aux_out_count].gpio = board_config.aux_out_4_gpio;
|
|
aux_out[aux_out_count].name = board_config.aux_out_4_name;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.aux_out_4_gpio);
|
|
aux_out_count++;
|
|
}
|
|
|
|
if (io_conf.pin_bit_mask > 0) {
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
}
|
|
|
|
// AIN
|
|
|
|
adc_oneshot_chan_cfg_t config = {
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
.atten = ADC_ATTEN_DB_12
|
|
};
|
|
|
|
if (board_config.aux_ain_1) {
|
|
aux_ain[aux_ain_count].adc = board_config.aux_ain_1_adc_channel;
|
|
aux_ain[aux_ain_count].name = board_config.aux_out_1_name;
|
|
ESP_ERROR_CHECK(adc_oneshot_config_channel(adc_handle, board_config.aux_ain_1_adc_channel, &config));
|
|
aux_ain_count++;
|
|
}
|
|
|
|
if (board_config.aux_ain_2) {
|
|
aux_ain[aux_ain_count].adc = board_config.aux_ain_2_adc_channel;
|
|
aux_ain[aux_ain_count].name = board_config.aux_out_2_name;
|
|
ESP_ERROR_CHECK(adc_oneshot_config_channel(adc_handle, board_config.aux_ain_2_adc_channel, &config));
|
|
aux_ain_count++;
|
|
}
|
|
}
|
|
|
|
esp_err_t aux_read(const char* name, bool* value)
|
|
{
|
|
for (int i = 0; i < aux_in_count; i++) {
|
|
if (strcmp(aux_in[i].name, name) == 0) {
|
|
*value = gpio_get_level(aux_in[i].gpio) == 1;
|
|
return ESP_OK;
|
|
}
|
|
}
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
|
|
esp_err_t aux_write(const char* name, bool value)
|
|
{
|
|
for (int i = 0; i < aux_out_count; i++) {
|
|
if (strcmp(aux_out[i].name, name) == 0) {
|
|
return gpio_set_level(aux_out[i].gpio, value);
|
|
}
|
|
}
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
|
|
esp_err_t aux_analog_read(const char* name, int* value)
|
|
{
|
|
for (int i = 0; i < aux_ain_count; i++) {
|
|
if (strcmp(aux_ain[i].name, name) == 0) {
|
|
int raw = 0;
|
|
esp_err_t ret = adc_oneshot_read(adc_handle, aux_ain[i].adc, &raw);
|
|
if (ret == ESP_OK) {
|
|
return adc_cali_raw_to_voltage(adc_cali_handle, raw, value);
|
|
} else {
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
// === Fim de: components/peripherals/src/aux_io.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/lm75a.c ===
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/queue.h"
|
|
#include "driver/gpio.h"
|
|
#include "driver/i2c_master.h"
|
|
|
|
#define I2C_MASTER_NUM I2C_NUM_1
|
|
#define I2C_MASTER_SCL_IO GPIO_NUM_22 // CONFIG_EXAMPLE_I2C_SCL /*!< gpio number for I2C master clock */
|
|
#define I2C_MASTER_SDA_IO GPIO_NUM_21 // CONFIG_EXAMPLE_I2C_SDA /*!< gpio number for I2C master data */
|
|
#define I2C_MASTER_FREQ_HZ 100000 // CONFIG_I2C_TRANS_SPEED /*!< I2C master clock frequency */
|
|
#define I2C_MASTER_TX_BUF_DISABLE 0 /*!< I2C master do not need buffer */
|
|
#define I2C_MASTER_RX_BUF_DISABLE 0 /*!< I2C master do not need buffer */
|
|
#define LM75A_SLAVE_ADDR 0x48 // CONFIG_LM75A_SLAVE_ADDR /*!< LM75A slave address, you can set any 7bit value */
|
|
#define ACK_VAL 0x0 /*!< I2C ack value */
|
|
#define NACK_VAL 0x1 /*!< I2C nack value */
|
|
#define WRITE_BIT I2C_MASTER_WRITE /*!< I2C master write */
|
|
#define READ_BIT I2C_MASTER_READ /*!< I2C master read */
|
|
#define ACK_CHECK_EN 0x1 /*!< I2C master will check ack from slave*/
|
|
#define ACK_CHECK_DIS 0x0 /*!< I2C master will not check ack from slave */
|
|
|
|
/*
|
|
#define GPIO_INPUT_IO_0 CONFIG_LM75A_OS_PIN
|
|
#define GPIO_OUTPUT_IO_0 CONFIG_LM75A_VCC_PIN
|
|
#define GPIO_OUTPUT_PIN_SEL (1ULL << GPIO_OUTPUT_IO_0)
|
|
#define GPIO_INPUT_PIN_SEL (1ULL << GPIO_INPUT_IO_0)
|
|
#define ESP_INTR_FLAG_DEFAULT 0
|
|
*/
|
|
|
|
// static xQueueHandle gpio_evt_queue = NULL;
|
|
// static int gpio_int_task_enable = 0;
|
|
// static TaskHandle_t gpio_int_task_handle = NULL;
|
|
|
|
/**
|
|
* @brief test code to read esp-i2c-slave
|
|
* We need to fill the buffer of esp slave device, then master can read them out.
|
|
*
|
|
* _______________________________________________________________________________________
|
|
* | start | slave_addr + rd_bit +ack | read n-1 bytes + ack | read 1 byte + nack | stop |
|
|
* --------|--------------------------|----------------------|--------------------|------|
|
|
*
|
|
*/
|
|
static esp_err_t i2c_master_read_slave(i2c_port_t i2c_num, uint8_t *data_rd, size_t size)
|
|
{
|
|
if (size == 0)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
|
|
i2c_master_start(cmd);
|
|
i2c_master_write_byte(cmd, (LM75A_SLAVE_ADDR << 1) | READ_BIT, ACK_CHECK_EN);
|
|
if (size > 1)
|
|
{
|
|
i2c_master_read(cmd, data_rd, size - 1, ACK_VAL);
|
|
}
|
|
i2c_master_read_byte(cmd, data_rd + size - 1, NACK_VAL);
|
|
i2c_master_stop(cmd);
|
|
esp_err_t ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_PERIOD_MS);
|
|
i2c_cmd_link_delete(cmd);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Test code to write esp-i2c-slave
|
|
* Master device write data to slave(both esp32),
|
|
* the data will be stored in slave buffer.
|
|
* We can read them out from slave buffer.
|
|
*
|
|
* ___________________________________________________________________
|
|
* | start | slave_addr + wr_bit + ack | write n bytes + ack | stop |
|
|
* --------|---------------------------|----------------------|------|
|
|
*
|
|
*/
|
|
static esp_err_t i2c_master_write_slave(i2c_port_t i2c_num, uint8_t *data_wr, size_t size)
|
|
{
|
|
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
|
|
i2c_master_start(cmd);
|
|
i2c_master_write_byte(cmd, (LM75A_SLAVE_ADDR << 1) | WRITE_BIT, ACK_CHECK_EN);
|
|
i2c_master_write(cmd, data_wr, size, ACK_CHECK_EN);
|
|
i2c_master_stop(cmd);
|
|
esp_err_t ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_PERIOD_MS);
|
|
i2c_cmd_link_delete(cmd);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief i2c master initialization
|
|
*/
|
|
static void i2c_master_init()
|
|
{
|
|
int i2c_master_port = I2C_MASTER_NUM;
|
|
i2c_config_t conf;
|
|
conf.mode = I2C_MODE_MASTER;
|
|
conf.sda_io_num = I2C_MASTER_SDA_IO;
|
|
conf.sda_pullup_en = GPIO_PULLUP_DISABLE;
|
|
conf.scl_io_num = I2C_MASTER_SCL_IO;
|
|
conf.scl_pullup_en = GPIO_PULLUP_DISABLE;
|
|
conf.master.clk_speed = I2C_MASTER_FREQ_HZ;
|
|
conf.clk_flags = 0;
|
|
|
|
i2c_param_config(i2c_master_port, &conf);
|
|
i2c_driver_install(i2c_master_port, conf.mode,
|
|
I2C_MASTER_RX_BUF_DISABLE,
|
|
I2C_MASTER_TX_BUF_DISABLE, 0);
|
|
}
|
|
|
|
int lm75a_read_temperature(int show)
|
|
{
|
|
uint8_t buf[2];
|
|
float tmp;
|
|
buf[0] = 0;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 1);
|
|
i2c_master_read_slave(I2C_MASTER_NUM, buf, 2);
|
|
tmp = buf[0];
|
|
if (buf[1] & 128)
|
|
tmp += 0.5;
|
|
if (show)
|
|
printf("lm75a_read_temperature=%.1f\n", tmp);
|
|
return tmp;
|
|
}
|
|
|
|
/*
|
|
static void IRAM_ATTR gpio_isr_handler(void *arg)
|
|
{
|
|
uint32_t gpio_num = (uint32_t)arg;
|
|
xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
|
|
}
|
|
|
|
static void gpio_int_task(void *arg)
|
|
{
|
|
uint32_t io_num;
|
|
gpio_int_task_enable = 1;
|
|
while (gpio_int_task_enable)
|
|
{
|
|
if (xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY))
|
|
{
|
|
|
|
// read temperature to clean int;
|
|
if (io_num == GPIO_INPUT_IO_0)
|
|
{
|
|
printf("GPIO[%d] intr, val: %d\n\n", io_num, gpio_get_level(io_num));
|
|
lm75a_read_temperature(0); // read to clean interrupt.
|
|
}
|
|
}
|
|
}
|
|
printf("quit gpio_int_task\n");
|
|
if (gpio_evt_queue)
|
|
{
|
|
vQueueDelete(gpio_evt_queue);
|
|
gpio_evt_queue = NULL;
|
|
}
|
|
gpio_int_task_handle = NULL;
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
void init_os_gpio()
|
|
{
|
|
printf("init_os_gpio!\n");
|
|
|
|
if (gpio_evt_queue == NULL)
|
|
gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
|
|
|
|
if (gpio_int_task_handle == NULL)
|
|
{
|
|
xTaskCreate(gpio_int_task, "gpio_int_task", 2048, NULL, 10, &gpio_int_task_handle);
|
|
// install gpio isr service
|
|
gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
|
|
// hook isr handler for specific gpio pin again
|
|
gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void *)GPIO_INPUT_IO_0);
|
|
}
|
|
}
|
|
|
|
static void deinit_os_gpio()
|
|
{
|
|
printf("deinit_os_gpio!\n");
|
|
|
|
if (gpio_int_task_handle)
|
|
{
|
|
gpio_isr_handler_remove(GPIO_INPUT_IO_0);
|
|
gpio_uninstall_isr_service();
|
|
gpio_int_task_enable = 0;
|
|
int io = 0;
|
|
xQueueSend(gpio_evt_queue, &io, 0); // send a fake signal to quit task.
|
|
}
|
|
}
|
|
|
|
static void lm75a_vcc_enable()
|
|
{
|
|
gpio_config_t io_conf;
|
|
// enable output for vcc
|
|
io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
|
|
io_conf.mode = GPIO_MODE_OUTPUT;
|
|
io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;
|
|
io_conf.pull_down_en = 0;
|
|
io_conf.pull_up_en = 0;
|
|
gpio_config(&io_conf);
|
|
|
|
// enable input for interrupt
|
|
io_conf.intr_type = GPIO_PIN_INTR_NEGEDGE; // GPIO_PIN_INTR_ANYEDGE;
|
|
io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL;
|
|
io_conf.mode = GPIO_MODE_INPUT;
|
|
io_conf.pull_up_en = 1;
|
|
gpio_set_pull_mode(GPIO_INPUT_IO_0, GPIO_FLOATING);
|
|
gpio_config(&io_conf);
|
|
gpio_set_level(GPIO_OUTPUT_IO_0, 1);
|
|
}
|
|
|
|
static void lm75a_vcc_disable()
|
|
{
|
|
gpio_set_level(GPIO_OUTPUT_IO_0, 0);
|
|
}
|
|
*/
|
|
|
|
void lm75a_init()
|
|
{
|
|
// lm75a_vcc_enable();
|
|
i2c_master_init();
|
|
}
|
|
|
|
void lm75a_deinit()
|
|
{
|
|
// deinit_os_gpio();
|
|
i2c_driver_delete(I2C_MASTER_NUM);
|
|
// lm75a_vcc_disable();
|
|
}
|
|
|
|
void lm75a_set_tos(int tos)
|
|
{
|
|
uint8_t buf[4];
|
|
printf("lm75a_set_tos: %d\n", tos);
|
|
// set Tos:
|
|
buf[0] = 0x3;
|
|
buf[1] = (tos & 0xff);
|
|
buf[2] = 0;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 3);
|
|
}
|
|
|
|
void lm75a_set_thys(int thys)
|
|
{
|
|
uint8_t buf[4];
|
|
printf("lm75a_set_thys: %d\n", thys);
|
|
// set Thyst:
|
|
buf[0] = 0x2;
|
|
buf[1] = (thys & 0xff);
|
|
buf[2] = 0;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 3);
|
|
}
|
|
|
|
void lm75a_get_tos()
|
|
{
|
|
uint8_t buf[4];
|
|
float tmp;
|
|
buf[0] = 0x3;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 1);
|
|
i2c_master_read_slave(I2C_MASTER_NUM, buf, 2);
|
|
tmp = buf[0];
|
|
if (buf[1] & 128)
|
|
tmp += 0.5;
|
|
|
|
printf("lm75a_get_tos: %.1f\n", tmp);
|
|
}
|
|
|
|
void lm75a_get_thys()
|
|
{
|
|
uint8_t buf[4];
|
|
float tmp;
|
|
buf[0] = 0x2;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 1);
|
|
i2c_master_read_slave(I2C_MASTER_NUM, buf, 2);
|
|
tmp = buf[0];
|
|
if (buf[1] & 128)
|
|
tmp += 0.5;
|
|
|
|
printf("lm75a_get_thys: %.1f\n", tmp);
|
|
}
|
|
|
|
void lm75a_set_int(int en)
|
|
{
|
|
uint8_t buf[2];
|
|
|
|
en = !!en;
|
|
if (en)
|
|
{
|
|
printf("lm75a_set_int: %d\n", en);
|
|
buf[0] = 0x1;
|
|
buf[1] = (1 << 1); // D1 set to 1;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 2);
|
|
i2c_master_read_slave(I2C_MASTER_NUM, buf, 2); // do one time read to clean interrupt before enter interrupt mode.
|
|
// gpio_set_intr_type(GPIO_INPUT_IO_0, GPIO_INTR_NEGEDGE);
|
|
// init_os_gpio();
|
|
}
|
|
else
|
|
{
|
|
printf("lm75a_set_int: %d\n", en);
|
|
// deinit_os_gpio();
|
|
buf[0] = 0x1;
|
|
buf[1] = 0;
|
|
i2c_master_write_slave(I2C_MASTER_NUM, buf, 2);
|
|
i2c_master_read_slave(I2C_MASTER_NUM, buf, 2); // do one time read to clean interrupt before enter interrupt mode.
|
|
}
|
|
}
|
|
|
|
void lm75a_get_osio()
|
|
{
|
|
// printf("os_io: %d\n", gpio_get_level(GPIO_INPUT_IO_0));
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/lm75a.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/onewire.c ===
|
|
/*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2014 zeroday nodemcu.com
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
* -------------------------------------------------------------------------------
|
|
* Portions copyright (C) 2000 Dallas Semiconductor Corporation, under the
|
|
* following additional terms:
|
|
*
|
|
* Except as contained in this notice, the name of Dallas Semiconductor
|
|
* shall not be used except as stated in the Dallas Semiconductor
|
|
* Branding Policy.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#include "rom/ets_sys.h"
|
|
|
|
#include "onewire.h"
|
|
|
|
#define ONEWIRE_SELECT_ROM 0x55
|
|
#define ONEWIRE_SKIP_ROM 0xcc
|
|
#define ONEWIRE_SEARCH 0xf0
|
|
#define ONEWIRE_CRC8_TABLE
|
|
|
|
static portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
|
|
|
|
// Waits up to `max_wait` microseconds for the specified pin to go high.
|
|
// Returns true if successful, false if the bus never comes high (likely
|
|
// shorted).
|
|
static inline bool _onewire_wait_for_bus(gpio_num_t pin, int max_wait)
|
|
{
|
|
bool state;
|
|
for (int i = 0; i < ((max_wait + 4) / 5); i++) {
|
|
if (gpio_get_level(pin))
|
|
break;
|
|
ets_delay_us(5);
|
|
}
|
|
state = gpio_get_level(pin);
|
|
// Wait an extra 1us to make sure the devices have an adequate recovery
|
|
// time before we drive things low again.
|
|
ets_delay_us(1);
|
|
return state;
|
|
}
|
|
|
|
static void setup_pin(gpio_num_t pin, bool open_drain)
|
|
{
|
|
gpio_set_direction(pin, open_drain ? GPIO_MODE_INPUT_OUTPUT_OD : GPIO_MODE_OUTPUT);
|
|
// gpio_set_pull_mode(pin, GPIO_PULLUP_ONLY);
|
|
}
|
|
|
|
// Perform the onewire reset function. We will wait up to 250uS for
|
|
// the bus to come high, if it doesn't then it is broken or shorted
|
|
// and we return false;
|
|
//
|
|
// Returns true if a device asserted a presence pulse, false otherwise.
|
|
//
|
|
bool onewire_reset(gpio_num_t pin)
|
|
{
|
|
setup_pin(pin, true);
|
|
|
|
gpio_set_level(pin, 1);
|
|
// wait until the wire is high... just in case
|
|
if (!_onewire_wait_for_bus(pin, 250))
|
|
return false;
|
|
|
|
gpio_set_level(pin, 0);
|
|
ets_delay_us(480);
|
|
|
|
portENTER_CRITICAL(&mux);
|
|
gpio_set_level(pin, 1); // allow it to float
|
|
ets_delay_us(70);
|
|
bool r = !gpio_get_level(pin);
|
|
portEXIT_CRITICAL(&mux);
|
|
|
|
// Wait for all devices to finish pulling the bus low before returning
|
|
if (!_onewire_wait_for_bus(pin, 410))
|
|
return false;
|
|
|
|
return r;
|
|
}
|
|
|
|
static bool _onewire_write_bit(gpio_num_t pin, bool v)
|
|
{
|
|
if (!_onewire_wait_for_bus(pin, 10))
|
|
return false;
|
|
|
|
portENTER_CRITICAL(&mux);
|
|
if (v) {
|
|
gpio_set_level(pin, 0); // drive output low
|
|
ets_delay_us(10);
|
|
gpio_set_level(pin, 1); // allow output high
|
|
ets_delay_us(55);
|
|
} else {
|
|
gpio_set_level(pin, 0); // drive output low
|
|
ets_delay_us(65);
|
|
gpio_set_level(pin, 1); // allow output high
|
|
}
|
|
ets_delay_us(1);
|
|
portEXIT_CRITICAL(&mux);
|
|
|
|
return true;
|
|
}
|
|
|
|
static int _onewire_read_bit(gpio_num_t pin)
|
|
{
|
|
if (!_onewire_wait_for_bus(pin, 10))
|
|
return -1;
|
|
|
|
portENTER_CRITICAL(&mux);
|
|
gpio_set_level(pin, 0);
|
|
ets_delay_us(2);
|
|
gpio_set_level(pin, 1); // let pin float, pull up will raise
|
|
ets_delay_us(11);
|
|
int r = gpio_get_level(pin); // Must sample within 15us of start
|
|
ets_delay_us(48);
|
|
portEXIT_CRITICAL(&mux);
|
|
|
|
return r;
|
|
}
|
|
|
|
// Write a byte. The writing code uses open-drain mode and expects the pullup
|
|
// resistor to pull the line high when not driven low. If you need strong
|
|
// power after the write (e.g. DS18B20 in parasite power mode) then call
|
|
// onewire_power() after this is complete to actively drive the line high.
|
|
//
|
|
bool onewire_write(gpio_num_t pin, uint8_t v)
|
|
{
|
|
for (uint8_t bitMask = 0x01; bitMask; bitMask <<= 1)
|
|
if (!_onewire_write_bit(pin, (bitMask & v)))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool onewire_write_bytes(gpio_num_t pin, const uint8_t* buf, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; i++)
|
|
if (!onewire_write(pin, buf[i]))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Read a byte
|
|
//
|
|
int onewire_read(gpio_num_t pin)
|
|
{
|
|
int r = 0;
|
|
|
|
for (uint8_t bitMask = 0x01; bitMask; bitMask <<= 1) {
|
|
int bit = _onewire_read_bit(pin);
|
|
if (bit < 0)
|
|
return -1;
|
|
else if (bit)
|
|
r |= bitMask;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
bool onewire_read_bytes(gpio_num_t pin, uint8_t* buf, size_t count)
|
|
{
|
|
size_t i;
|
|
int b;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
b = onewire_read(pin);
|
|
if (b < 0)
|
|
return false;
|
|
buf[i] = b;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool onewire_select(gpio_num_t pin, onewire_addr_t addr)
|
|
{
|
|
uint8_t i;
|
|
|
|
if (!onewire_write(pin, ONEWIRE_SELECT_ROM))
|
|
return false;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (!onewire_write(pin, addr & 0xff))
|
|
return false;
|
|
addr >>= 8;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool onewire_skip_rom(gpio_num_t pin)
|
|
{
|
|
return onewire_write(pin, ONEWIRE_SKIP_ROM);
|
|
}
|
|
|
|
bool onewire_power(gpio_num_t pin)
|
|
{
|
|
// Make sure the bus is not being held low before driving it high, or we
|
|
// may end up shorting ourselves out.
|
|
if (!_onewire_wait_for_bus(pin, 10))
|
|
return false;
|
|
|
|
setup_pin(pin, false);
|
|
gpio_set_level(pin, 1);
|
|
|
|
return true;
|
|
}
|
|
|
|
void onewire_depower(gpio_num_t pin)
|
|
{
|
|
setup_pin(pin, true);
|
|
}
|
|
|
|
void onewire_search_start(onewire_search_t* search)
|
|
{
|
|
// reset the search state
|
|
memset(search, 0, sizeof(*search));
|
|
}
|
|
|
|
void onewire_search_prefix(onewire_search_t* search, uint8_t family_code)
|
|
{
|
|
uint8_t i;
|
|
|
|
search->rom_no[0] = family_code;
|
|
for (i = 1; i < 8; i++) {
|
|
search->rom_no[i] = 0;
|
|
}
|
|
search->last_discrepancy = 64;
|
|
search->last_device_found = false;
|
|
}
|
|
|
|
// Perform a search. If the next device has been successfully enumerated, its
|
|
// ROM address will be returned. If there are no devices, no further
|
|
// devices, or something horrible happens in the middle of the
|
|
// enumeration then ONEWIRE_NONE is returned. Use OneWire::reset_search() to
|
|
// start over.
|
|
//
|
|
// --- Replaced by the one from the Dallas Semiconductor web site ---
|
|
//--------------------------------------------------------------------------
|
|
// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing
|
|
// search state.
|
|
// Return 1 : device found, ROM number in ROM_NO buffer
|
|
// 0 : device not found, end of search
|
|
//
|
|
onewire_addr_t onewire_search_next(onewire_search_t* search, gpio_num_t pin)
|
|
{
|
|
//TODO: add more checking for read/write errors
|
|
uint8_t id_bit_number;
|
|
uint8_t last_zero, search_result;
|
|
int rom_byte_number;
|
|
int8_t id_bit, cmp_id_bit;
|
|
onewire_addr_t addr;
|
|
unsigned char rom_byte_mask;
|
|
bool search_direction;
|
|
|
|
// initialize for search
|
|
id_bit_number = 1;
|
|
last_zero = 0;
|
|
rom_byte_number = 0;
|
|
rom_byte_mask = 1;
|
|
search_result = 0;
|
|
|
|
// if the last call was not the last one
|
|
if (!search->last_device_found) {
|
|
// 1-Wire reset
|
|
if (!onewire_reset(pin)) {
|
|
// reset the search
|
|
search->last_discrepancy = 0;
|
|
search->last_device_found = false;
|
|
return ONEWIRE_NONE;
|
|
}
|
|
|
|
// issue the search command
|
|
onewire_write(pin, ONEWIRE_SEARCH);
|
|
|
|
// loop to do the search
|
|
do {
|
|
// read a bit and its complement
|
|
id_bit = _onewire_read_bit(pin);
|
|
cmp_id_bit = _onewire_read_bit(pin);
|
|
|
|
if ((id_bit == 1) && (cmp_id_bit == 1))
|
|
break;
|
|
else {
|
|
// all devices coupled have 0 or 1
|
|
if (id_bit != cmp_id_bit)
|
|
search_direction = id_bit; // bit write value for search
|
|
else {
|
|
// if this discrepancy if before the Last Discrepancy
|
|
// on a previous next then pick the same as last time
|
|
if (id_bit_number < search->last_discrepancy)
|
|
search_direction = ((search->rom_no[rom_byte_number] & rom_byte_mask) > 0);
|
|
else
|
|
// if equal to last pick 1, if not then pick 0
|
|
search_direction = (id_bit_number == search->last_discrepancy);
|
|
|
|
// if 0 was picked then record its position in LastZero
|
|
if (!search_direction)
|
|
last_zero = id_bit_number;
|
|
}
|
|
|
|
// set or clear the bit in the ROM byte rom_byte_number
|
|
// with mask rom_byte_mask
|
|
if (search_direction)
|
|
search->rom_no[rom_byte_number] |= rom_byte_mask;
|
|
else
|
|
search->rom_no[rom_byte_number] &= ~rom_byte_mask;
|
|
|
|
// serial number search direction write bit
|
|
_onewire_write_bit(pin, search_direction);
|
|
|
|
// increment the byte counter id_bit_number
|
|
// and shift the mask rom_byte_mask
|
|
id_bit_number++;
|
|
rom_byte_mask <<= 1;
|
|
|
|
// if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
|
|
if (rom_byte_mask == 0) {
|
|
rom_byte_number++;
|
|
rom_byte_mask = 1;
|
|
}
|
|
}
|
|
} while (rom_byte_number < 8); // loop until through all ROM bytes 0-7
|
|
|
|
// if the search was successful then
|
|
if (!(id_bit_number < 65)) {
|
|
// search successful so set last_discrepancy,last_device_found,search_result
|
|
search->last_discrepancy = last_zero;
|
|
|
|
// check for last device
|
|
if (search->last_discrepancy == 0)
|
|
search->last_device_found = true;
|
|
|
|
search_result = 1;
|
|
}
|
|
}
|
|
|
|
// if no device found then reset counters so next 'search' will be like a first
|
|
if (!search_result || !search->rom_no[0]) {
|
|
search->last_discrepancy = 0;
|
|
search->last_device_found = false;
|
|
return ONEWIRE_NONE;
|
|
} else {
|
|
addr = 0;
|
|
for (rom_byte_number = 7; rom_byte_number >= 0; rom_byte_number--) {
|
|
addr = (addr << 8) | search->rom_no[rom_byte_number];
|
|
}
|
|
//printf("Ok I found something at %08x%08x...\n", (uint32_t)(addr >> 32), (uint32_t)addr);
|
|
}
|
|
return addr;
|
|
}
|
|
|
|
// The 1-Wire CRC scheme is described in Maxim Application Note 27:
|
|
// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
|
|
//
|
|
|
|
#ifdef ONEWIRE_CRC8_TABLE
|
|
// This table comes from Dallas sample code where it is freely reusable,
|
|
// though Copyright (c) 2000 Dallas Semiconductor Corporation
|
|
static const uint8_t dscrc_table[] = {
|
|
0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,
|
|
157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,
|
|
35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,
|
|
190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,
|
|
70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
|
|
219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,
|
|
101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,
|
|
248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,
|
|
140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,
|
|
17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
|
|
175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,
|
|
50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,
|
|
202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,
|
|
87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,
|
|
233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
|
|
116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53
|
|
};
|
|
|
|
//
|
|
// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
|
|
// and the registers. (note: this might better be done without to
|
|
// table, it would probably be smaller and certainly fast enough
|
|
// compared to all those delayMicrosecond() calls. But I got
|
|
// confused, so I use this table from the examples.)
|
|
//
|
|
uint8_t onewire_crc8(const uint8_t* data, uint8_t len)
|
|
{
|
|
uint8_t crc = 0;
|
|
|
|
while (len--)
|
|
crc = dscrc_table[crc ^ *data++];
|
|
|
|
return crc;
|
|
}
|
|
#else
|
|
//
|
|
// Compute a Dallas Semiconductor 8 bit CRC directly.
|
|
// this is much slower, but much smaller, than the lookup table.
|
|
//
|
|
uint8_t onewire_crc8(const uint8_t* data, uint8_t len)
|
|
{
|
|
uint8_t crc = 0;
|
|
|
|
while (len--)
|
|
{
|
|
uint8_t inbyte = *data++;
|
|
for (int i = 8; i; i--)
|
|
{
|
|
uint8_t mix = (crc ^ inbyte) & 0x01;
|
|
crc >>= 1;
|
|
if (mix)
|
|
crc ^= 0x8C;
|
|
inbyte >>= 1;
|
|
}
|
|
}
|
|
return crc;
|
|
}
|
|
#endif /* ONEWIRE_CRC8_TABLE */
|
|
|
|
// Compute the 1-Wire CRC16 and compare it against the received CRC.
|
|
// Example usage (reading a DS2408):
|
|
// // Put everything in a buffer so we can compute the CRC easily.
|
|
// uint8_t buf[13];
|
|
// buf[0] = 0xF0; // Read PIO Registers
|
|
// buf[1] = 0x88; // LSB address
|
|
// buf[2] = 0x00; // MSB address
|
|
// WriteBytes(net, buf, 3); // Write 3 cmd bytes
|
|
// ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16
|
|
// if (!CheckCRC16(buf, 11, &buf[11])) {
|
|
// // Handle error.
|
|
// }
|
|
//
|
|
// @param input - Array of bytes to checksum.
|
|
// @param len - How many bytes to use.
|
|
// @param inverted_crc - The two CRC16 bytes in the received data.
|
|
// This should just point into the received data,
|
|
// *not* at a 16-bit integer.
|
|
// @param crc - The crc starting value (optional)
|
|
// @return 1, iff the CRC matches.
|
|
bool onewire_check_crc16(const uint8_t* input, size_t len, const uint8_t* inverted_crc, uint16_t crc_iv)
|
|
{
|
|
uint16_t crc = ~onewire_crc16(input, len, crc_iv);
|
|
return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1];
|
|
}
|
|
|
|
// Compute a Dallas Semiconductor 16 bit CRC. This is required to check
|
|
// the integrity of data received from many 1-Wire devices. Note that the
|
|
// CRC computed here is *not* what you'll get from the 1-Wire network,
|
|
// for two reasons:
|
|
// 1) The CRC is transmitted bitwise inverted.
|
|
// 2) Depending on the endian-ness of your processor, the binary
|
|
// representation of the two-byte return value may have a different
|
|
// byte order than the two bytes you get from 1-Wire.
|
|
// @param input - Array of bytes to checksum.
|
|
// @param len - How many bytes to use.
|
|
// @param crc - The crc starting value (optional)
|
|
// @return The CRC16, as defined by Dallas Semiconductor.
|
|
uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv)
|
|
{
|
|
uint16_t crc = crc_iv;
|
|
static const uint8_t oddparity[16] = { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
|
|
|
|
uint16_t i;
|
|
for (i = 0; i < len; i++) {
|
|
// Even though we're just copying a byte from the input,
|
|
// we'll be doing 16-bit computation with it.
|
|
uint16_t cdata = input[i];
|
|
cdata = (cdata ^ crc) & 0xff;
|
|
crc >>= 8;
|
|
|
|
if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4])
|
|
crc ^= 0xC001;
|
|
|
|
cdata <<= 6;
|
|
crc ^= cdata;
|
|
cdata <<= 1;
|
|
crc ^= cdata;
|
|
}
|
|
return crc;
|
|
}
|
|
// === Fim de: components/peripherals/src/onewire.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/onewire.h ===
|
|
/*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2014 zeroday nodemcu.com
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
* -------------------------------------------------------------------------------
|
|
* Portions copyright (C) 2000 Dallas Semiconductor Corporation, under the
|
|
* following additional terms:
|
|
*
|
|
* Except as contained in this notice, the name of Dallas Semiconductor
|
|
* shall not be used except as stated in the Dallas Semiconductor
|
|
* Branding Policy.
|
|
*/
|
|
|
|
#ifndef ONEWIRE_H_
|
|
#define ONEWIRE_H_
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "driver/gpio.h"
|
|
|
|
/**
|
|
* Type used to hold all 1-Wire device ROM addresses (64-bit)
|
|
*/
|
|
typedef uint64_t onewire_addr_t;
|
|
|
|
/**
|
|
* Structure to contain the current state for onewire_search_next(), etc
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t rom_no[8];
|
|
uint8_t last_discrepancy;
|
|
bool last_device_found;
|
|
} onewire_search_t;
|
|
|
|
/**
|
|
* ::ONEWIRE_NONE is an invalid ROM address that will never occur in a device
|
|
* (CRC mismatch), and so can be useful as an indicator for "no-such-device",
|
|
* etc.
|
|
*/
|
|
#define ONEWIRE_NONE ((onewire_addr_t)(0xffffffffffffffffLL))
|
|
|
|
/**
|
|
* @brief Perform a 1-Wire reset cycle.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
*
|
|
* @return `true` if at least one device responds with a presence pulse,
|
|
* `false` if no devices were detected (or the bus is shorted, etc)
|
|
*/
|
|
bool onewire_reset(gpio_num_t pin);
|
|
|
|
/**
|
|
* @brief Issue a 1-Wire "ROM select" command to select a particular device.
|
|
*
|
|
* It is necessary to call ::onewire_reset() before calling this function.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
* @param addr The ROM address of the device to select
|
|
*
|
|
* @return `true` if the "ROM select" command could be successfully issued,
|
|
* `false` if there was an error.
|
|
*/
|
|
bool onewire_select(gpio_num_t pin, const onewire_addr_t addr);
|
|
|
|
/**
|
|
* @brief Issue a 1-Wire "skip ROM" command to select *all* devices on the bus.
|
|
*
|
|
* It is necessary to call ::onewire_reset() before calling this function.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
*
|
|
* @return `true` if the "skip ROM" command could be successfully issued,
|
|
* `false` if there was an error.
|
|
*/
|
|
bool onewire_skip_rom(gpio_num_t pin);
|
|
|
|
/**
|
|
* @brief Write a byte on the onewire bus.
|
|
*
|
|
* The writing code uses open-drain mode and expects the pullup resistor to
|
|
* pull the line high when not driven low. If you need strong power after the
|
|
* write (e.g. DS18B20 in parasite power mode) then call ::onewire_power()
|
|
* after this is complete to actively drive the line high.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
* @param v The byte value to write
|
|
*
|
|
* @return `true` if successful, `false` on error.
|
|
*/
|
|
bool onewire_write(gpio_num_t pin, uint8_t v);
|
|
|
|
/**
|
|
* @brief Write multiple bytes on the 1-Wire bus.
|
|
*
|
|
* See ::onewire_write() for more info.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
* @param buf A pointer to the buffer of bytes to be written
|
|
* @param count Number of bytes to write
|
|
*
|
|
* @return `true` if all bytes written successfully, `false` on error.
|
|
*/
|
|
bool onewire_write_bytes(gpio_num_t pin, const uint8_t *buf, size_t count);
|
|
|
|
/**
|
|
* @brief Read a byte from a 1-Wire device.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
*
|
|
* @return the read byte on success, negative value on error.
|
|
*/
|
|
int onewire_read(gpio_num_t pin);
|
|
|
|
/**
|
|
* @brief Read multiple bytes from a 1-Wire device.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
* @param[out] buf A pointer to the buffer to contain the read bytes
|
|
* @param count Number of bytes to read
|
|
*
|
|
* @return `true` on success, `false` on error.
|
|
*/
|
|
bool onewire_read_bytes(gpio_num_t pin, uint8_t *buf, size_t count);
|
|
|
|
/**
|
|
* @brief Actively drive the bus high to provide extra power for certain
|
|
* operations of parasitically-powered devices.
|
|
*
|
|
* For parasitically-powered devices which need more power than can be
|
|
* provided via the normal pull-up resistor, it may be necessary for some
|
|
* operations to drive the bus actively high. This function can be used to
|
|
* perform that operation.
|
|
*
|
|
* The bus can be depowered once it is no longer needed by calling
|
|
* ::onewire_depower(), or it will be depowered automatically the next time
|
|
* ::onewire_reset() is called to start another command.
|
|
*
|
|
* @note Make sure the device(s) you are powering will not pull more current
|
|
* than the ESP32/ESP8266 is able to supply via its GPIO pins (this is
|
|
* especially important when multiple devices are on the same bus and
|
|
* they are all performing a power-intensive operation at the same time
|
|
* (i.e. multiple DS18B20 sensors, which have all been given a
|
|
* "convert T" operation by using ::onewire_skip_rom())).
|
|
*
|
|
* @note This routine will check to make sure that the bus is already high
|
|
* before driving it, to make sure it doesn't attempt to drive it high
|
|
* while something else is pulling it low (which could cause a reset or
|
|
* damage the ESP32/ESP8266).
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
*
|
|
* @return `true` on success, `false` on error.
|
|
*/
|
|
bool onewire_power(gpio_num_t pin);
|
|
|
|
/**
|
|
* @brief Stop forcing power onto the bus.
|
|
*
|
|
* You only need to do this if you previously called ::onewire_power() to drive
|
|
* the bus high and now want to allow it to float instead. Note that
|
|
* onewire_reset() will also automatically depower the bus first, so you do
|
|
* not need to call this first if you just want to start a new operation.
|
|
*
|
|
* @param pin The GPIO pin connected to the 1-Wire bus.
|
|
*/
|
|
void onewire_depower(gpio_num_t pin);
|
|
|
|
/**
|
|
* @brief Clear the search state so that it will start from the beginning on
|
|
* the next call to ::onewire_search_next().
|
|
*
|
|
* @param[out] search The onewire_search_t structure to reset.
|
|
*/
|
|
void onewire_search_start(onewire_search_t *search);
|
|
|
|
/**
|
|
* @brief Setup the search to search for devices with the specified
|
|
* "family code".
|
|
*
|
|
* @param[out] search The onewire_search_t structure to update.
|
|
* @param family_code The "family code" to search for.
|
|
*/
|
|
void onewire_search_prefix(onewire_search_t *search, uint8_t family_code);
|
|
|
|
/**
|
|
* @brief Search for the next device on the bus.
|
|
*
|
|
* The order of returned device addresses is deterministic. You will always
|
|
* get the same devices in the same order.
|
|
*
|
|
* @note It might be a good idea to check the CRC to make sure you didn't get
|
|
* garbage.
|
|
*
|
|
* @return the address of the next device on the bus, or ::ONEWIRE_NONE if
|
|
* there is no next address. ::ONEWIRE_NONE might also mean that
|
|
* the bus is shorted, there are no devices, or you have already
|
|
* retrieved all of them.
|
|
*/
|
|
onewire_addr_t onewire_search_next(onewire_search_t *search, gpio_num_t pin);
|
|
|
|
/**
|
|
* @brief Compute a Dallas Semiconductor 8 bit CRC.
|
|
*
|
|
* These are used in the ROM address and scratchpad registers to verify the
|
|
* transmitted data is correct.
|
|
*/
|
|
uint8_t onewire_crc8(const uint8_t *data, uint8_t len);
|
|
|
|
/**
|
|
* @brief Compute the 1-Wire CRC16 and compare it against the received CRC.
|
|
*
|
|
* Example usage (reading a DS2408):
|
|
* @code{.c}
|
|
* // Put everything in a buffer so we can compute the CRC easily.
|
|
* uint8_t buf[13];
|
|
* buf[0] = 0xF0; // Read PIO Registers
|
|
* buf[1] = 0x88; // LSB address
|
|
* buf[2] = 0x00; // MSB address
|
|
* onewire_write_bytes(pin, buf, 3); // Write 3 cmd bytes
|
|
* onewire_read_bytes(pin, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16
|
|
* if (!onewire_check_crc16(buf, 11, &buf[11])) {
|
|
* // TODO: Handle error.
|
|
* }
|
|
* @endcode
|
|
*
|
|
* @param input Array of bytes to checksum.
|
|
* @param len Number of bytes in `input`
|
|
* @param inverted_crc The two CRC16 bytes in the received data.
|
|
* This should just point into the received data,
|
|
* *not* at a 16-bit integer.
|
|
* @param crc_iv The crc starting value (optional)
|
|
*
|
|
* @return `true` if the CRC matches, `false` otherwise.
|
|
*/
|
|
bool onewire_check_crc16(const uint8_t* input, size_t len, const uint8_t* inverted_crc, uint16_t crc_iv);
|
|
|
|
/**
|
|
* @brief Compute a Dallas Semiconductor 16 bit CRC.
|
|
*
|
|
* This is required to check the integrity of data received from many 1-Wire
|
|
* devices. Note that the CRC computed here is *not* what you'll get from the
|
|
* 1-Wire network, for two reasons:
|
|
*
|
|
* 1. The CRC is transmitted bitwise inverted.
|
|
* 2. Depending on the endian-ness of your processor, the binary
|
|
* representation of the two-byte return value may have a different
|
|
* byte order than the two bytes you get from 1-Wire.
|
|
*
|
|
* @param input Array of bytes to checksum.
|
|
* @param len How many bytes are in `input`.
|
|
* @param crc_iv The crc starting value (optional)
|
|
*
|
|
* @return the CRC16, as defined by Dallas Semiconductor.
|
|
*/
|
|
uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv);
|
|
|
|
|
|
#endif /* ONEWIRE_H_ */
|
|
// === Fim de: components/peripherals/src/onewire.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/ds18x20.c ===
|
|
/*
|
|
* Copyright (c) 2016 Grzegorz Hetman <ghetman@gmail.com>
|
|
* Copyright (c) 2016 Alex Stewart <foogod@gmail.com>
|
|
* Copyright (c) 2018 Ruslan V. Uss <unclerus@gmail.com>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the copyright holder nor the names of itscontributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
#include <math.h>
|
|
#include <esp_log.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#include "ds18x20.h"
|
|
|
|
#define ds18x20_WRITE_SCRATCHPAD 0x4E
|
|
#define ds18x20_READ_SCRATCHPAD 0xBE
|
|
#define ds18x20_COPY_SCRATCHPAD 0x48
|
|
#define ds18x20_READ_EEPROM 0xB8
|
|
#define ds18x20_READ_PWRSUPPLY 0xB4
|
|
#define ds18x20_SEARCHROM 0xF0
|
|
#define ds18x20_SKIP_ROM 0xCC
|
|
#define ds18x20_READROM 0x33
|
|
#define ds18x20_MATCHROM 0x55
|
|
#define ds18x20_ALARMSEARCH 0xEC
|
|
#define ds18x20_CONVERT_T 0x44
|
|
|
|
#define CHECK(x) do { esp_err_t __; if ((__ = x) != ESP_OK) return __; } while (0)
|
|
#define CHECK_ARG(VAL) do { if (!(VAL)) return ESP_ERR_INVALID_ARG; } while (0)
|
|
|
|
static portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
|
|
|
|
static const char* TAG = "ds18x20";
|
|
|
|
esp_err_t ds18x20_measure(gpio_num_t pin, ds18x20_addr_t addr, bool wait)
|
|
{
|
|
if (!onewire_reset(pin))
|
|
return ESP_ERR_INVALID_RESPONSE;
|
|
|
|
if (addr == DS18X20_ANY)
|
|
onewire_skip_rom(pin);
|
|
else
|
|
onewire_select(pin, addr);
|
|
|
|
portENTER_CRITICAL(&mux);
|
|
onewire_write(pin, ds18x20_CONVERT_T);
|
|
// For parasitic devices, power must be applied within 10us after issuing
|
|
// the convert command.
|
|
onewire_power(pin);
|
|
portEXIT_CRITICAL(&mux);
|
|
|
|
if (wait){
|
|
vTaskDelay(pdMS_TO_TICKS(750));
|
|
onewire_depower(pin);
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18x20_read_scratchpad(gpio_num_t pin, ds18x20_addr_t addr, uint8_t* buffer)
|
|
{
|
|
CHECK_ARG(buffer);
|
|
|
|
uint8_t crc;
|
|
uint8_t expected_crc;
|
|
|
|
if (!onewire_reset(pin))
|
|
return ESP_ERR_INVALID_RESPONSE;
|
|
|
|
if (addr == DS18X20_ANY)
|
|
onewire_skip_rom(pin);
|
|
else
|
|
onewire_select(pin, addr);
|
|
onewire_write(pin, ds18x20_READ_SCRATCHPAD);
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
buffer[i] = onewire_read(pin);
|
|
crc = onewire_read(pin);
|
|
|
|
expected_crc = onewire_crc8(buffer, 8);
|
|
if (crc != expected_crc)
|
|
{
|
|
ESP_LOGE(TAG, "CRC check failed reading scratchpad: %02x %02x %02x %02x %02x %02x %02x %02x : %02x (expected %02x)", buffer[0], buffer[1],
|
|
buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7], crc, expected_crc);
|
|
return ESP_ERR_INVALID_CRC;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18x20_write_scratchpad(gpio_num_t pin, ds18x20_addr_t addr, uint8_t* buffer)
|
|
{
|
|
CHECK_ARG(buffer);
|
|
|
|
if (!onewire_reset(pin))
|
|
return ESP_ERR_INVALID_RESPONSE;
|
|
|
|
if (addr == DS18X20_ANY)
|
|
onewire_skip_rom(pin);
|
|
else
|
|
onewire_select(pin, addr);
|
|
onewire_write(pin, ds18x20_WRITE_SCRATCHPAD);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
onewire_write(pin, buffer[i]);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18x20_copy_scratchpad(gpio_num_t pin, ds18x20_addr_t addr)
|
|
{
|
|
if (!onewire_reset(pin))
|
|
return ESP_ERR_INVALID_RESPONSE;
|
|
|
|
if (addr == DS18X20_ANY)
|
|
onewire_skip_rom(pin);
|
|
else
|
|
onewire_select(pin, addr);
|
|
|
|
portENTER_CRITICAL(&mux);
|
|
onewire_write(pin, ds18x20_COPY_SCRATCHPAD);
|
|
// For parasitic devices, power must be applied within 10us after issuing
|
|
// the convert command.
|
|
onewire_power(pin);
|
|
portEXIT_CRITICAL(&mux);
|
|
|
|
// And then it needs to keep that power up for 10ms.
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
onewire_depower(pin);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18b20_read_temperature(gpio_num_t pin, ds18x20_addr_t addr, int16_t* temperature)
|
|
{
|
|
CHECK_ARG(temperature);
|
|
|
|
uint8_t scratchpad[8];
|
|
int16_t temp;
|
|
|
|
CHECK(ds18x20_read_scratchpad(pin, addr, scratchpad));
|
|
|
|
temp = scratchpad[1] << 8 | scratchpad[0];
|
|
|
|
*temperature = ((int16_t)temp * 625.0) / 100;
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18s20_read_temperature(gpio_num_t pin, ds18x20_addr_t addr, int16_t* temperature)
|
|
{
|
|
CHECK_ARG(temperature);
|
|
|
|
uint8_t scratchpad[8];
|
|
int16_t temp;
|
|
|
|
CHECK(ds18x20_read_scratchpad(pin, addr, scratchpad));
|
|
|
|
temp = scratchpad[1] << 8 | scratchpad[0];
|
|
temp = ((temp & 0xfffe) << 3) + (16 - scratchpad[6]) - 4;
|
|
|
|
*temperature = (temp * 625) / 100 - 25;
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18x20_read_temperature(gpio_num_t pin, ds18x20_addr_t addr, int16_t* temperature)
|
|
{
|
|
if ((uint8_t)addr == DS18B20_FAMILY_ID) {
|
|
return ds18b20_read_temperature(pin, addr, temperature);
|
|
} else {
|
|
return ds18s20_read_temperature(pin, addr, temperature);
|
|
}
|
|
}
|
|
|
|
esp_err_t ds18b20_measure_and_read(gpio_num_t pin, ds18x20_addr_t addr, int16_t* temperature)
|
|
{
|
|
CHECK_ARG(temperature);
|
|
|
|
CHECK(ds18x20_measure(pin, addr, true));
|
|
return ds18b20_read_temperature(pin, addr, temperature);
|
|
}
|
|
|
|
esp_err_t ds18s20_measure_and_read(gpio_num_t pin, ds18x20_addr_t addr, int16_t* temperature)
|
|
{
|
|
CHECK_ARG(temperature);
|
|
|
|
CHECK(ds18x20_measure(pin, addr, true));
|
|
return ds18s20_read_temperature(pin, addr, temperature);
|
|
}
|
|
|
|
esp_err_t ds18x20_measure_and_read(gpio_num_t pin, ds18x20_addr_t addr, int16_t* temperature)
|
|
{
|
|
CHECK_ARG(temperature);
|
|
|
|
CHECK(ds18x20_measure(pin, addr, true));
|
|
return ds18x20_read_temperature(pin, addr, temperature);
|
|
}
|
|
|
|
esp_err_t ds18x20_measure_and_read_multi(gpio_num_t pin, ds18x20_addr_t* addr_list, size_t addr_count, int16_t* result_list)
|
|
{
|
|
CHECK_ARG(result_list && addr_count);
|
|
|
|
CHECK(ds18x20_measure(pin, DS18X20_ANY, true));
|
|
|
|
return ds18x20_read_temp_multi(pin, addr_list, addr_count, result_list);
|
|
}
|
|
|
|
esp_err_t ds18x20_scan_devices(gpio_num_t pin, ds18x20_addr_t* addr_list, size_t addr_count, size_t* found)
|
|
{
|
|
CHECK_ARG(addr_list && addr_count);
|
|
|
|
onewire_search_t search;
|
|
onewire_addr_t addr;
|
|
|
|
*found = 0;
|
|
onewire_search_start(&search);
|
|
while ((addr = onewire_search_next(&search, pin)) != ONEWIRE_NONE)
|
|
{
|
|
uint8_t family_id = (uint8_t)addr;
|
|
if (family_id == DS18B20_FAMILY_ID || family_id == DS18S20_FAMILY_ID)
|
|
{
|
|
if (*found < addr_count)
|
|
addr_list[*found] = addr;
|
|
*found += 1;
|
|
}
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t ds18x20_read_temp_multi(gpio_num_t pin, ds18x20_addr_t* addr_list, size_t addr_count, int16_t* result_list)
|
|
{
|
|
CHECK_ARG(result_list);
|
|
|
|
esp_err_t res = ESP_OK;
|
|
for (size_t i = 0; i < addr_count; i++)
|
|
{
|
|
esp_err_t tmp = ds18x20_read_temperature(pin, addr_list[i], &result_list[i]);
|
|
if (tmp != ESP_OK)
|
|
res = tmp;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/ds18x20.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/led.c ===
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/timers.h"
|
|
#include "esp_log.h"
|
|
#include "driver/gpio.h"
|
|
#include "led.h"
|
|
#include "board_config.h"
|
|
#include "evse_error.h"
|
|
#include "evse_api.h"
|
|
|
|
#define LED_UPDATE_INTERVAL_MS 100
|
|
#define BLOCK_TIME pdMS_TO_TICKS(10)
|
|
|
|
static const char *TAG = "led";
|
|
|
|
typedef struct {
|
|
gpio_num_t gpio;
|
|
bool on : 1;
|
|
uint16_t ontime;
|
|
uint16_t offtime;
|
|
TimerHandle_t timer;
|
|
led_pattern_t pattern;
|
|
uint8_t blink_count;
|
|
} led_t;
|
|
|
|
static led_t leds[LED_ID_MAX] = {0};
|
|
static TimerHandle_t led_update_timer = NULL;
|
|
static evse_state_t led_state = -1;
|
|
|
|
// ----------------------------
|
|
// Funções Internas
|
|
// ----------------------------
|
|
|
|
static void led_update_timer_callback(TimerHandle_t xTimer);
|
|
static void led_update(void);
|
|
static void led_apply_by_state(evse_state_t state);
|
|
|
|
static inline void led_gpio_write(gpio_num_t gpio, bool level) {
|
|
if (gpio != GPIO_NUM_NC)
|
|
gpio_set_level(gpio, level);
|
|
}
|
|
|
|
static void led_timer_callback(TimerHandle_t xTimer)
|
|
{
|
|
led_t *led = (led_t *)pvTimerGetTimerID(xTimer);
|
|
led->on = !led->on;
|
|
led_gpio_write(led->gpio, led->on);
|
|
uint32_t next_time = led->on ? led->ontime : led->offtime;
|
|
|
|
xTimerChangePeriod(led->timer, pdMS_TO_TICKS(next_time), BLOCK_TIME);
|
|
}
|
|
|
|
// ----------------------------
|
|
// Inicialização
|
|
// ----------------------------
|
|
|
|
void led_init(void)
|
|
{
|
|
gpio_config_t io_conf = {
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_ENABLE,
|
|
.pin_bit_mask = 0
|
|
};
|
|
|
|
for (int i = 0; i < LED_ID_MAX; i++) {
|
|
leds[i].gpio = GPIO_NUM_NC;
|
|
}
|
|
|
|
if (board_config.led_stop) {
|
|
leds[LED_ID_STOP].gpio = board_config.led_stop_gpio;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.led_stop_gpio);
|
|
}
|
|
|
|
if (board_config.led_charging) {
|
|
leds[LED_ID_CHARGING].gpio = board_config.led_charging_gpio;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.led_charging_gpio);
|
|
}
|
|
|
|
if (board_config.led_error) {
|
|
leds[LED_ID_ERROR].gpio = board_config.led_error_gpio;
|
|
io_conf.pin_bit_mask |= BIT64(board_config.led_error_gpio);
|
|
}
|
|
|
|
if (io_conf.pin_bit_mask != 0) {
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
}
|
|
|
|
if (!led_update_timer) {
|
|
led_update_timer = xTimerCreate("led_update_timer",
|
|
pdMS_TO_TICKS(LED_UPDATE_INTERVAL_MS),
|
|
pdTRUE, NULL,
|
|
led_update_timer_callback);
|
|
if (led_update_timer) {
|
|
xTimerStart(led_update_timer, BLOCK_TIME);
|
|
} else {
|
|
ESP_LOGE(TAG, "Failed to create LED update timer");
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------
|
|
// API Pública
|
|
// ----------------------------
|
|
|
|
void led_set_state(led_id_t led_id, uint16_t ontime, uint16_t offtime)
|
|
{
|
|
if (led_id >= LED_ID_MAX) return;
|
|
|
|
led_t *led = &leds[led_id];
|
|
if (led->gpio == GPIO_NUM_NC) return;
|
|
|
|
// Evita reconfiguração idêntica
|
|
if (led->ontime == ontime && led->offtime == offtime)
|
|
return;
|
|
|
|
if (led->timer) {
|
|
xTimerStop(led->timer, BLOCK_TIME);
|
|
}
|
|
|
|
led->ontime = ontime;
|
|
led->offtime = offtime;
|
|
|
|
if (ontime == 0) {
|
|
led->on = false;
|
|
led_gpio_write(led->gpio, 0);
|
|
} else if (offtime == 0) {
|
|
led->on = true;
|
|
led_gpio_write(led->gpio, 1);
|
|
} else {
|
|
led->on = true;
|
|
led_gpio_write(led->gpio, 1);
|
|
|
|
if (!led->timer) {
|
|
led->timer = xTimerCreate("led_timer", pdMS_TO_TICKS(ontime),
|
|
pdFALSE, (void *)led, led_timer_callback);
|
|
}
|
|
|
|
if (led->timer) {
|
|
xTimerStart(led->timer, BLOCK_TIME);
|
|
}
|
|
}
|
|
}
|
|
|
|
void led_apply_pattern(led_id_t id, led_pattern_t pattern)
|
|
{
|
|
if (id >= LED_ID_MAX) return;
|
|
|
|
led_t *led = &leds[id];
|
|
if (led->gpio == GPIO_NUM_NC) return;
|
|
|
|
if (led->pattern == pattern) return;
|
|
|
|
if (led->timer) {
|
|
xTimerStop(led->timer, BLOCK_TIME);
|
|
}
|
|
|
|
led->pattern = pattern;
|
|
led->blink_count = 0;
|
|
|
|
switch (pattern) {
|
|
case LED_PATTERN_OFF:
|
|
led_set_state(id, 0, 0);
|
|
break;
|
|
case LED_PATTERN_ON:
|
|
led_set_state(id, 1, 0);
|
|
break;
|
|
case LED_PATTERN_BLINK:
|
|
led_set_state(id, 500, 500);
|
|
break;
|
|
case LED_PATTERN_BLINK_FAST:
|
|
led_set_state(id, 200, 200);
|
|
break;
|
|
case LED_PATTERN_BLINK_SLOW:
|
|
led_set_state(id, 300, 1700);
|
|
break;
|
|
case LED_PATTERN_CHARGING_EFFECT:
|
|
led_set_state(id, 2000, 1000);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ----------------------------
|
|
// Controle por Estado
|
|
// ----------------------------
|
|
|
|
static void led_apply_by_state(evse_state_t state)
|
|
{
|
|
// Reset todos
|
|
led_apply_pattern(LED_ID_STOP, LED_PATTERN_OFF);
|
|
led_apply_pattern(LED_ID_CHARGING, LED_PATTERN_OFF);
|
|
led_apply_pattern(LED_ID_ERROR, LED_PATTERN_OFF);
|
|
|
|
switch (state) {
|
|
case EVSE_STATE_A:
|
|
led_apply_pattern(LED_ID_STOP, LED_PATTERN_ON);
|
|
break;
|
|
case EVSE_STATE_B1:
|
|
case EVSE_STATE_B2:
|
|
case EVSE_STATE_C1:
|
|
led_apply_pattern(LED_ID_CHARGING, LED_PATTERN_ON);
|
|
break;
|
|
case EVSE_STATE_C2:
|
|
led_apply_pattern(LED_ID_CHARGING, LED_PATTERN_CHARGING_EFFECT);
|
|
break;
|
|
case EVSE_STATE_D1:
|
|
case EVSE_STATE_D2:
|
|
led_apply_pattern(LED_ID_CHARGING, LED_PATTERN_BLINK_FAST);
|
|
break;
|
|
case EVSE_STATE_E:
|
|
case EVSE_STATE_F:
|
|
led_apply_pattern(LED_ID_ERROR, LED_PATTERN_BLINK_FAST);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ----------------------------
|
|
// Timer Update
|
|
// ----------------------------
|
|
|
|
static void led_update(void)
|
|
{
|
|
if (evse_error_is_active()) {
|
|
led_apply_pattern(LED_ID_ERROR, LED_PATTERN_BLINK_FAST);
|
|
led_apply_pattern(LED_ID_STOP, LED_PATTERN_OFF);
|
|
led_apply_pattern(LED_ID_CHARGING, LED_PATTERN_OFF);
|
|
return;
|
|
}
|
|
|
|
evse_state_t current = evse_get_state();
|
|
|
|
if (current != led_state) {
|
|
led_state = current;
|
|
led_apply_by_state(current);
|
|
}
|
|
}
|
|
|
|
static void led_update_timer_callback(TimerHandle_t xTimer)
|
|
{
|
|
(void)xTimer;
|
|
led_update();
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/led.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/rcm.c ===
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "driver/gpio.h"
|
|
#include "esp_log.h"
|
|
|
|
#include "rcm.h"
|
|
#include "board_config.h"
|
|
#include "evse_api.h"
|
|
|
|
// static bool do_test = false;
|
|
|
|
// static bool triggered = false;
|
|
|
|
// static bool test_triggered = false;
|
|
|
|
// static void IRAM_ATTR rcm_isr_handler(void* arg)
|
|
// {
|
|
// if (!do_test) {
|
|
// triggered = true;
|
|
// } else {
|
|
// test_triggered = true;
|
|
// }
|
|
// }
|
|
|
|
void rcm_init(void)
|
|
{
|
|
if (board_config.rcm) {
|
|
gpio_config_t io_conf = {};
|
|
|
|
io_conf.mode = GPIO_MODE_OUTPUT;
|
|
io_conf.pin_bit_mask = BIT64(board_config.rcm_test_gpio);
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
|
|
io_conf.mode = GPIO_MODE_INPUT;
|
|
// io_conf.intr_type = GPIO_INTR_POSEDGE;
|
|
io_conf.pin_bit_mask = BIT64(board_config.rcm_gpio);
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
//ESP_ERROR_CHECK(gpio_isr_handler_add(board_config.rcm_gpio, rcm_isr_handler, NULL));
|
|
}
|
|
}
|
|
|
|
bool rcm_test(void)
|
|
{
|
|
// do_test = true;
|
|
// test_triggered = false;
|
|
|
|
// gpio_set_level(board_config.rcm_test_gpio, 1);
|
|
// vTaskDelay(pdMS_TO_TICKS(100));
|
|
// gpio_set_level(board_config.rcm_test_gpio, 0);
|
|
|
|
// do_test = false;
|
|
|
|
// return test_triggered;
|
|
|
|
gpio_set_level(board_config.rcm_test_gpio, 1);
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
bool success = gpio_get_level(board_config.rcm_gpio) == 1;
|
|
gpio_set_level(board_config.rcm_test_gpio, 0);
|
|
|
|
return success;
|
|
}
|
|
|
|
bool rcm_is_triggered(void)
|
|
{
|
|
// bool _triggered = triggered;
|
|
// if (gpio_get_level(board_config.rcm_gpio) == 0) {
|
|
// triggered = false;
|
|
// }
|
|
// return _triggered;
|
|
if (gpio_get_level(board_config.rcm_gpio) == 1) {
|
|
vTaskDelay(pdMS_TO_TICKS(1));
|
|
return gpio_get_level(board_config.rcm_gpio) == 1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
// === Fim de: components/peripherals/src/rcm.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/adc.c ===
|
|
#include "adc.h"
|
|
#include "esp_log.h"
|
|
|
|
const static char* TAG = "adc";
|
|
|
|
adc_oneshot_unit_handle_t adc_handle;
|
|
|
|
adc_cali_handle_t adc_cali_handle;
|
|
|
|
void adc_init(void)
|
|
{
|
|
adc_oneshot_unit_init_cfg_t conf = {
|
|
.unit_id = ADC_UNIT_1
|
|
};
|
|
ESP_ERROR_CHECK(adc_oneshot_new_unit(&conf, &adc_handle));
|
|
|
|
bool calibrated = false;
|
|
|
|
#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
|
|
if (!calibrated) {
|
|
ESP_LOGI(TAG, "Calibration scheme version is %s", "Curve Fitting");
|
|
adc_cali_curve_fitting_config_t cali_config = {
|
|
.unit_id = ADC_UNIT_1,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
};
|
|
if (adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle) == ESP_OK) {
|
|
calibrated = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
|
|
if (!calibrated) {
|
|
ESP_LOGI(TAG, "Calibration scheme version is %s", "Line Fitting");
|
|
adc_cali_line_fitting_config_t cali_config = {
|
|
.unit_id = ADC_UNIT_1,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
#if CONFIG_IDF_TARGET_ESP32
|
|
.default_vref = 1100
|
|
#endif
|
|
};
|
|
if (adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle) == ESP_OK) {
|
|
calibrated = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!calibrated) {
|
|
ESP_LOGE(TAG, "No calibration scheme");
|
|
ESP_ERROR_CHECK(ESP_FAIL);
|
|
}
|
|
}
|
|
// === Fim de: components/peripherals/src/adc.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/adc121s021_dma.c ===
|
|
#include "driver/spi_master.h"
|
|
#include "driver/gpio.h"
|
|
#include "esp_log.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "adc121s021_dma.h"
|
|
|
|
#define TAG "adc_dma"
|
|
|
|
#define PIN_NUM_MOSI 23
|
|
#define PIN_NUM_MISO 19
|
|
#define PIN_NUM_CLK 18
|
|
#define PIN_NUM_CS 5
|
|
|
|
#define SPI_HOST_USED SPI2_HOST
|
|
#define SAMPLE_SIZE_BYTES 2
|
|
#define ADC_BITS 12
|
|
|
|
static spi_device_handle_t adc_spi;
|
|
|
|
void adc121s021_dma_init(void)
|
|
{
|
|
spi_bus_config_t buscfg = {
|
|
.mosi_io_num = PIN_NUM_MOSI,
|
|
.miso_io_num = PIN_NUM_MISO,
|
|
.sclk_io_num = PIN_NUM_CLK,
|
|
.quadwp_io_num = -1,
|
|
.quadhd_io_num = -1,
|
|
.max_transfer_sz = SAMPLE_SIZE_BYTES,
|
|
};
|
|
|
|
spi_device_interface_config_t devcfg = {
|
|
.clock_speed_hz = 6000000, // 6 MHz
|
|
.mode = 0,
|
|
.spics_io_num = PIN_NUM_CS,
|
|
.queue_size = 2,
|
|
.flags = SPI_DEVICE_NO_DUMMY,
|
|
};
|
|
|
|
ESP_ERROR_CHECK(spi_bus_initialize(SPI_HOST_USED, &buscfg, SPI_DMA_CH_AUTO));
|
|
ESP_ERROR_CHECK(spi_bus_add_device(SPI_HOST_USED, &devcfg, &adc_spi));
|
|
}
|
|
|
|
bool adc121s021_dma_get_sample(uint16_t *sample)
|
|
{
|
|
uint8_t tx_buffer[2] = {0x00, 0x00}; // Dummy TX
|
|
uint8_t rx_buffer[2] = {0};
|
|
|
|
spi_transaction_t t = {
|
|
.length = 16, // 16 bits
|
|
.tx_buffer = tx_buffer,
|
|
.rx_buffer = rx_buffer,
|
|
.flags = 0
|
|
};
|
|
|
|
esp_err_t err = spi_device_transmit(adc_spi, &t);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "SPI transmit error: %s", esp_err_to_name(err));
|
|
return false;
|
|
}
|
|
|
|
// Extrai os 12 bits significativos da resposta do ADC121S021
|
|
*sample = ((rx_buffer[0] << 8) | rx_buffer[1]) & 0x0FFF;
|
|
|
|
return true;
|
|
}
|
|
|
|
// === Fim de: components/peripherals/src/adc121s021_dma.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/src/peripherals.c ===
|
|
#include "peripherals.h"
|
|
#include "adc.h"
|
|
#include "led.h"
|
|
#include "buzzer.h"
|
|
#include "proximity.h"
|
|
#include "ac_relay.h"
|
|
#include "socket_lock.h"
|
|
#include "rcm.h"
|
|
#include "aux_io.h"
|
|
#include "ntc_sensor.h"
|
|
|
|
void peripherals_init(void)
|
|
{
|
|
ac_relay_init();
|
|
led_init();
|
|
buzzer_init();
|
|
adc_init();
|
|
proximity_init();
|
|
// socket_lock_init();
|
|
// rcm_init();
|
|
//energy_meter_init();
|
|
// aux_init();
|
|
ntc_sensor_init();
|
|
}
|
|
// === Fim de: components/peripherals/src/peripherals.c ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/adc121s021_dma.h ===
|
|
#ifndef ADC_DMA_H_
|
|
#define ADC_DMA_H_
|
|
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
|
|
void adc121s021_dma_init(void);
|
|
bool adc121s021_dma_get_sample(uint16_t *sample);
|
|
|
|
|
|
#endif /* ADC_DMA_h_ */
|
|
|
|
// === Fim de: components/peripherals/include/adc121s021_dma.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/peripherals.h ===
|
|
#ifndef PERIPHERALS_H
|
|
#define PERIPHERALS_H
|
|
|
|
void peripherals_init(void);
|
|
|
|
#endif /* PERIPHERALS_H */
|
|
|
|
// === Fim de: components/peripherals/include/peripherals.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/rcm.h ===
|
|
#ifndef RCM_H_
|
|
#define RCM_H_
|
|
|
|
#include <stdbool.h>
|
|
|
|
/**
|
|
* @brief Initialize residual current monitor
|
|
*
|
|
*/
|
|
void rcm_init(void);
|
|
|
|
/**
|
|
* @brief Test residual current monitor
|
|
*
|
|
* @return true
|
|
* @return false
|
|
*/
|
|
bool rcm_test(void);
|
|
|
|
/**
|
|
* @brief Residual current monitor was detected leakage
|
|
*
|
|
* @return true
|
|
* @return false
|
|
*/
|
|
bool rcm_is_triggered(void);
|
|
|
|
#endif /* RCM_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/rcm.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/aux_io.h ===
|
|
#ifndef AUX_IO_H_
|
|
#define AUX_IO_H_
|
|
|
|
#include "esp_err.h"
|
|
|
|
/**
|
|
* @brief Initialize aux
|
|
*
|
|
*/
|
|
void aux_init(void);
|
|
|
|
/**
|
|
* @brief Read digital input
|
|
*
|
|
* @param name
|
|
* @param value
|
|
* @return esp_err_t
|
|
*/
|
|
esp_err_t aux_read(const char *name, bool *value);
|
|
|
|
/**
|
|
* @brief Write digial output
|
|
*
|
|
* @param name
|
|
* @param value
|
|
* @return esp_err_t
|
|
*/
|
|
esp_err_t aux_write(const char *name, bool value);
|
|
|
|
/**
|
|
* @brief Read analog input
|
|
*
|
|
* @param name
|
|
* @param value
|
|
* @return esp_err_t
|
|
*/
|
|
esp_err_t aux_analog_read(const char *name, int *value);
|
|
|
|
#endif /* AUX_IO_H_ */
|
|
// === Fim de: components/peripherals/include/aux_io.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/led.h ===
|
|
#ifndef LED_H_
|
|
#define LED_H_
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
|
|
/**
|
|
* @brief Identificadores dos LEDs disponíveis no hardware
|
|
*/
|
|
typedef enum {
|
|
LED_ID_STOP,
|
|
LED_ID_CHARGING,
|
|
LED_ID_ERROR,
|
|
LED_ID_MAX
|
|
} led_id_t;
|
|
|
|
/**
|
|
* @brief Padrões de comportamento possíveis para os LEDs
|
|
*/
|
|
typedef enum {
|
|
LED_PATTERN_OFF, ///< LED sempre desligado
|
|
LED_PATTERN_ON, ///< LED sempre ligado
|
|
LED_PATTERN_BLINK, ///< Pisca com ciclo padrão (500ms on / 500ms off)
|
|
LED_PATTERN_BLINK_FAST, ///< Pisca rápido (200ms / 200ms)
|
|
LED_PATTERN_BLINK_SLOW, ///< Pisca lento (300ms / 1700ms)
|
|
LED_PATTERN_CHARGING_EFFECT ///< Efeito visual para carregamento (2s on / 1s off)
|
|
} led_pattern_t;
|
|
|
|
/**
|
|
* @brief Inicializa os LEDs com base na configuração da placa
|
|
* Deve ser chamada uma única vez na inicialização do sistema.
|
|
*/
|
|
void led_init(void);
|
|
|
|
/**
|
|
* @brief Define diretamente o tempo ligado/desligado de um LED.
|
|
* Pode ser usado para padrões personalizados.
|
|
*
|
|
* @param led_id Identificador do LED (ver enum led_id_t)
|
|
* @param ontime Tempo ligado em milissegundos
|
|
* @param offtime Tempo desligado em milissegundos
|
|
*/
|
|
void led_set_state(led_id_t led_id, uint16_t ontime, uint16_t offtime);
|
|
|
|
/**
|
|
* @brief Aplica um dos padrões de piscar definidos ao LED
|
|
*
|
|
* @param led_id Identificador do LED (ver enum led_id_t)
|
|
* @param pattern Padrão desejado (ver enum led_pattern_t)
|
|
*/
|
|
void led_apply_pattern(led_id_t led_id, led_pattern_t pattern);
|
|
|
|
#endif /* LED_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/led.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/buzzer.h ===
|
|
#ifndef BUZZER_H_
|
|
#define BUZZER_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
/**
|
|
* @brief Inicializa o buzzer e inicia monitoramento automático do estado EVSE.
|
|
*/
|
|
void buzzer_init(void);
|
|
|
|
/**
|
|
* @brief Liga e desliga o buzzer manualmente (uso interno ou testes).
|
|
*/
|
|
void buzzer_on(void);
|
|
void buzzer_off(void);
|
|
|
|
/**
|
|
* @brief Ativa o buzzer por um período fixo (em milissegundos).
|
|
*/
|
|
void buzzer_beep_ms(uint16_t ms);
|
|
|
|
#endif /* BUZZER_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/buzzer.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/ac_relay.h ===
|
|
#ifndef AC_RELAY_H_
|
|
#define AC_RELAY_H_
|
|
|
|
#include <stdbool.h>
|
|
|
|
/**
|
|
* @brief Inicializa o relé de corrente alternada.
|
|
*/
|
|
void ac_relay_init(void);
|
|
|
|
/**
|
|
* @brief Define o estado do relé de corrente alternada.
|
|
*
|
|
* @param state true para ligar, false para desligar.
|
|
*/
|
|
void ac_relay_set_state(bool state);
|
|
|
|
/**
|
|
* @brief Retorna o estado atual do relé de corrente alternada.
|
|
*
|
|
* @return true se estiver ligado, false se desligado.
|
|
*/
|
|
bool ac_relay_get_state(void);
|
|
|
|
#endif /* AC_RELAY_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/ac_relay.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/lm75a.h ===
|
|
#ifndef LM75A_H
|
|
#define LM75A_H
|
|
|
|
#include "esp_err.h" // Para o uso de tipos de erro do ESP-IDF, caso esteja utilizando.
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @brief Inicializa o sensor LM75A.
|
|
*
|
|
* Configura o sensor para leitura e define os pinos de comunicação.
|
|
*/
|
|
esp_err_t lm75a_init(void);
|
|
|
|
/**
|
|
* @brief Desinicializa o sensor LM75A.
|
|
*
|
|
* Libera os recursos usados pelo sensor.
|
|
*/
|
|
esp_err_t lm75a_deinit(void);
|
|
|
|
/**
|
|
* @brief Lê a temperatura do LM75A.
|
|
*
|
|
* @param show Se for 1, a temperatura será exibida em algum tipo de log ou interface.
|
|
* Se for 0, o valor é apenas retornado sem exibição.
|
|
* @return A temperatura lida em graus Celsius.
|
|
*/
|
|
float lm75a_read_temperature(int show);
|
|
|
|
/**
|
|
* @brief Define o valor do limite de temperatura (T_OS) para o sensor LM75A.
|
|
*
|
|
* @param tos O limite de temperatura de sobrecarga (T_OS) em graus Celsius.
|
|
* @return ESP_OK em caso de sucesso ou código de erro se falhar.
|
|
*/
|
|
esp_err_t lm75a_set_tos(int tos);
|
|
|
|
/**
|
|
* @brief Define o valor do limite de temperatura de histerese (T_HYS) para o sensor LM75A.
|
|
*
|
|
* @param thys O limite de histerese de temperatura (T_HYS) em graus Celsius.
|
|
* @return ESP_OK em caso de sucesso ou código de erro se falhar.
|
|
*/
|
|
esp_err_t lm75a_set_thys(int thys);
|
|
|
|
/**
|
|
* @brief Obtém o limite de temperatura de sobrecarga (T_OS) do sensor LM75A.
|
|
*
|
|
* @return O valor atual de T_OS em graus Celsius.
|
|
*/
|
|
int lm75a_get_tos(void);
|
|
|
|
/**
|
|
* @brief Obtém o limite de temperatura de histerese (T_HYS) do sensor LM75A.
|
|
*
|
|
* @return O valor atual de T_HYS em graus Celsius.
|
|
*/
|
|
int lm75a_get_thys(void);
|
|
|
|
/**
|
|
* @brief Habilita ou desabilita a interrupção do LM75A.
|
|
*
|
|
* @param en 1 para habilitar a interrupção, 0 para desabilitar.
|
|
* @return ESP_OK em caso de sucesso ou código de erro se falhar.
|
|
*/
|
|
esp_err_t lm75a_set_int(int en);
|
|
|
|
/**
|
|
* @brief Obtém o estado do pino OS (Overtemperature Shutdown) do LM75A.
|
|
*
|
|
* @return 1 se o pino OS estiver ativo (indica que a temperatura de sobrecarga foi atingida),
|
|
* 0 caso contrário.
|
|
*/
|
|
int lm75a_get_osio(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* LM75A_H */
|
|
|
|
// === Fim de: components/peripherals/include/lm75a.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/ntc_sensor.h ===
|
|
#ifndef NTC_SENSOR_H_
|
|
#define NTC_SENSOR_H_
|
|
|
|
/**
|
|
* @brief Initialize ntc senso
|
|
*
|
|
*/
|
|
void ntc_sensor_init(void);
|
|
|
|
/**
|
|
* @brief Return temperature after temp_sensor_measure
|
|
*
|
|
* @return float
|
|
*/
|
|
float ntc_temp_sensor(void);
|
|
|
|
#endif /* NTC_SENSOR_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/ntc_sensor.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/proximity.h ===
|
|
#ifndef PROXIMITY_H_
|
|
#define PROXIMITY_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
/**
|
|
* @brief Initialize proximity check
|
|
*
|
|
*/
|
|
void proximity_init(void);
|
|
|
|
/**
|
|
* @brief Return measured value of max current on PP
|
|
*
|
|
* @return current in A
|
|
*/
|
|
uint8_t proximity_get_max_current(void);
|
|
|
|
#endif /* PROXIMITY_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/proximity.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/socket_lock.h ===
|
|
#ifndef SOCKED_LOCK_H_
|
|
#define SOCKED_LOCK_H_
|
|
|
|
#include "esp_err.h"
|
|
|
|
typedef enum
|
|
{
|
|
SOCKED_LOCK_STATUS_IDLE,
|
|
SOCKED_LOCK_STATUS_OPERATING,
|
|
SOCKED_LOCK_STATUS_LOCKING_FAIL,
|
|
SOCKED_LOCK_STATUS_UNLOCKING_FAIL
|
|
} socket_lock_status_t;
|
|
|
|
/**
|
|
* @brief Initialize socket lock
|
|
*
|
|
*/
|
|
void socket_lock_init(void);
|
|
|
|
/**
|
|
* @brief Get socket lock detection on high, stored in NVS
|
|
*
|
|
* @return true when locked has zero resistance
|
|
* @return false when unlocked has zero resistance
|
|
*/
|
|
bool socket_lock_is_detection_high(void);
|
|
|
|
/**
|
|
* @brief Set socket lock detection on high, stored in NVS
|
|
*
|
|
* @param detection_high
|
|
*/
|
|
void socket_lock_set_detection_high(bool detection_high);
|
|
|
|
/**
|
|
* @brief Get socket lock operating time
|
|
*
|
|
* @return time in ms
|
|
*/
|
|
uint16_t socket_lock_get_operating_time(void);
|
|
|
|
/**
|
|
* @brief Set socket lock operating time
|
|
*
|
|
* @param operating_time - time in ms
|
|
* @return esp_err_t
|
|
*/
|
|
esp_err_t socket_lock_set_operating_time(uint16_t operating_time);
|
|
|
|
/**
|
|
* @brief Get socket lock retry count
|
|
*
|
|
* @return retry count
|
|
*/
|
|
uint8_t socket_lock_get_retry_count(void);
|
|
|
|
/**
|
|
* @brief Set socket lock retry count
|
|
*
|
|
* @param retry_count
|
|
*/
|
|
void socket_lock_set_retry_count(uint8_t retry_count);
|
|
|
|
/**
|
|
* @brief Get socket lock break time
|
|
*
|
|
* @return time in ms
|
|
*/
|
|
uint16_t socket_lock_get_break_time(void);
|
|
|
|
/**
|
|
* @brief Set socket lock break time
|
|
*
|
|
* @param break_time
|
|
* @return esp_err_t
|
|
*/
|
|
esp_err_t socket_lock_set_break_time(uint16_t break_time);
|
|
|
|
/**
|
|
* @brief Set socke lock to locked / unlocked state
|
|
*
|
|
* @param locked
|
|
*/
|
|
void socket_lock_set_locked(bool locked);
|
|
|
|
/**
|
|
* @brief Get socket lock status
|
|
*
|
|
* @return socket_lock_status_t
|
|
*/
|
|
socket_lock_status_t socket_lock_get_status(void);
|
|
|
|
/**
|
|
* @brief Read the current physical lock state using the detection pin.
|
|
*/
|
|
bool socket_lock_is_locked_state(void);
|
|
|
|
|
|
#endif /* SOCKED_LOCK_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/socket_lock.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/adc.h ===
|
|
#ifndef ADC_H_
|
|
#define ADC_H_
|
|
|
|
#include "esp_adc/adc_oneshot.h"
|
|
#include "esp_adc/adc_cali.h"
|
|
#include "esp_adc/adc_cali_scheme.h"
|
|
|
|
extern adc_oneshot_unit_handle_t adc_handle;
|
|
|
|
extern adc_cali_handle_t adc_cali_handle;
|
|
|
|
void adc_init(void);
|
|
|
|
#endif /* ADC_H_ */
|
|
// === Fim de: components/peripherals/include/adc.h ===
|
|
|
|
|
|
// === Início de: components/peripherals/include/temp_sensor.h ===
|
|
#ifndef TEMP_SENSOR_H_
|
|
#define TEMP_SENSOR_H_
|
|
|
|
#include <stdint.h>
|
|
#include "esp_err.h"
|
|
|
|
/**
|
|
* @brief Initialize DS18S20 temperature sensor bus
|
|
*
|
|
*/
|
|
void temp_sensor_init(void);
|
|
|
|
/**
|
|
* @brief Get found sensor count
|
|
*
|
|
* @return uint8_t
|
|
*/
|
|
uint8_t temp_sensor_get_count(void);
|
|
|
|
/**
|
|
* @brief Return lowest temperature after temp_sensor_measure
|
|
*
|
|
* @return int16_t
|
|
*/
|
|
int16_t temp_sensor_get_low(void);
|
|
|
|
/**
|
|
* @brief Return highest temperature after temp_sensor_measure
|
|
*
|
|
* @return int
|
|
*/
|
|
int temp_sensor_get_high(void);
|
|
|
|
/**
|
|
* @brief Return temperature sensor error
|
|
*
|
|
* @return bool
|
|
*/
|
|
bool temp_sensor_is_error(void);
|
|
|
|
#endif /* TEMP_SENSOR_H_ */
|
|
|
|
// === Fim de: components/peripherals/include/temp_sensor.h ===
|