3235 lines
97 KiB
C
3235 lines
97 KiB
C
.
|
|
|
|
// === 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_core.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, "Pressed Button");
|
|
handle_button_press();
|
|
}
|
|
|
|
if (notification & RELEASED_BIT && pressed) {
|
|
pressed = false;
|
|
ESP_LOGI(TAG, "Reladead Buttton");
|
|
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();
|
|
meter_manager_evse_start();
|
|
|
|
// 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/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";
|
|
|
|
// Memoization do estado atual do relé (salvo em RAM)
|
|
static int last_state = -1;
|
|
|
|
/**
|
|
* @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,
|
|
.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, 0); ///< Ensure relay starts OFF
|
|
last_state = 0;
|
|
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)
|
|
{
|
|
if (state == last_state) {
|
|
// Estado não mudou; evita log e escrita desnecessária.
|
|
return;
|
|
}
|
|
last_state = 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 ? 1 : 0);
|
|
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 != 0);
|
|
}
|
|
|
|
// === 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 "esp_log.h"
|
|
#include "adc121s021_dma.h"
|
|
#include "spi_bus_manager.h"
|
|
|
|
#define TAG "adc_dma"
|
|
|
|
#define PIN_NUM_CS 5
|
|
#define SAMPLE_SIZE_BYTES 2
|
|
#define ADC_BITS 12
|
|
#define SPI_CLOCK_HZ (6 * 1000 * 1000) // 6 MHz
|
|
|
|
static spi_device_handle_t adc_spi = NULL;
|
|
|
|
void adc121s021_dma_init(void)
|
|
{
|
|
if (adc_spi) {
|
|
ESP_LOGW(TAG, "ADC121S021 já foi inicializado.");
|
|
return;
|
|
}
|
|
|
|
if (!spi_bus_manager_is_initialized()) {
|
|
ESP_LOGI(TAG, "SPI bus não inicializado. Inicializando...");
|
|
esp_err_t err = spi_bus_manager_init(); // 🔧 CORRIGIDO: sem argumentos
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "Falha ao inicializar o SPI bus: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
}
|
|
|
|
spi_device_interface_config_t devcfg = {
|
|
.clock_speed_hz = SPI_CLOCK_HZ,
|
|
.mode = 0,
|
|
.spics_io_num = PIN_NUM_CS,
|
|
.queue_size = 2,
|
|
.flags = SPI_DEVICE_NO_DUMMY,
|
|
.pre_cb = NULL,
|
|
.post_cb = NULL,
|
|
};
|
|
|
|
esp_err_t err = spi_bus_add_device(spi_bus_manager_get_host(), &devcfg, &adc_spi);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "Falha ao registrar ADC121S021 no SPI: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "ADC121S021 registrado no SPI com sucesso.");
|
|
}
|
|
|
|
bool adc121s021_dma_get_sample(uint16_t *sample)
|
|
{
|
|
if (!adc_spi) {
|
|
ESP_LOGE(TAG, "ADC SPI não inicializado!");
|
|
return false;
|
|
}
|
|
|
|
uint8_t tx_buffer[2] = {0x00, 0x00}; // Dummy
|
|
uint8_t rx_buffer[2] = {0};
|
|
|
|
spi_transaction_t t = {
|
|
.length = 16,
|
|
.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, "Erro na transmissão SPI: %s", esp_err_to_name(err));
|
|
return false;
|
|
}
|
|
|
|
*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 ===
|