admin/chargeflow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adicionar primeiro

Browse Source
This commit is contained in:
PlxEV
2025-06-06 21:17:25 +01:00
parent c188084ba4
commit 282e7f517b
841 changed files with 199592 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

348
main_back2 Executable file
View File

@@ -0,0 +1,348 @@
#include <string.h>
#include <stdbool.h>
#include <sys/param.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_ota_ops.h"
#include "esp_log.h"
#include "esp_err.h"
#include "nvs_flash.h"
#include "esp_event.h"
#include "esp_spiffs.h"
#include "driver/gpio.h"
#include "evse_api.h"
#include "peripherals.h"
#include "led.h"
#include "api.h"
#include "protocols.h"
#include "serial_mt.h"
#include "board_config.h"
#include "wifi.h"
#include "logger.h"
// #include "ocpp.h"
// #include "currentshaper.h"
// #include "serial_mdb.h"
// #include "meter.h"
// #include "rc522_2.h"
// #include "main_wiegand.h"
// #include "app_main.h"
// #include "sync_slave.h"
// #include "sync_master.h"
#define AP_CONNECTION_TIMEOUT 60000 // 60sec
#define RESET_HOLD_TIME 10000 // 10sec
#define PRESS_BIT BIT0
#define RELEASED_BIT BIT1
static const char *TAG = "app_main";
static TaskHandle_t user_input_task;
static evse_state_t led_state = -1;
static void reset_and_reboot(void)
{
ESP_LOGW(TAG, "All settings will be erased...");
ESP_ERROR_CHECK(nvs_flash_erase());
ESP_LOGW(TAG, "Rebooting...");
vTaskDelay(pdMS_TO_TICKS(500));
esp_restart();
}
static void wifi_event_task_func(void *param)
{
EventBits_t mode_bits;
while (true)
{
// led_set_off(LED_ID_WIFI);
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)
{
// led_set_state(LED_ID_WIFI, 100, 900);
if (xEventGroupWaitBits(wifi_event_group, WIFI_AP_CONNECTED_BIT | WIFI_STA_MODE_BIT, pdFALSE, pdFALSE, pdMS_TO_TICKS(AP_CONNECTION_TIMEOUT)) & WIFI_AP_CONNECTED_BIT)
{
// led_set_state(LED_ID_WIFI, 1900, 100);
do
{
} while (!(xEventGroupWaitBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT | WIFI_STA_MODE_BIT, pdFALSE, pdFALSE, portMAX_DELAY) & WIFI_AP_DISCONNECTED_BIT));
}
else
{
if (xEventGroupGetBits(wifi_event_group) & WIFI_AP_MODE_BIT)
{
// serial_mdb_set_meter_test(false);
wifi_ap_stop();
}
}
}
else if (mode_bits & WIFI_STA_MODE_BIT)
{
// led_set_state(LED_ID_WIFI, 500, 500);
if (xEventGroupWaitBits(wifi_event_group, WIFI_STA_CONNECTED_BIT | WIFI_AP_MODE_BIT, pdFALSE, pdFALSE, portMAX_DELAY) & WIFI_STA_CONNECTED_BIT)
{
// led_set_on(LED_ID_WIFI);
do
{
} while (!(xEventGroupWaitBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT | WIFI_AP_MODE_BIT, pdFALSE, pdFALSE, portMAX_DELAY) & WIFI_STA_DISCONNECTED_BIT));
}
}
}
}
static void user_input_task_func(void *param)
{
uint32_t notification;
bool pressed = false;
TickType_t press_tick = 0;
while (true)
{
if (xTaskNotifyWait(0x00, 0xff, &notification, portMAX_DELAY))
{
if (notification & PRESS_BIT)
{
press_tick = xTaskGetTickCount();
pressed = true;
}
if (notification & RELEASED_BIT)
{
if (pressed)
{ // sometimes after connect debug UART emit RELEASED_BIT without preceding PRESS_BIT
if (xTaskGetTickCount() - press_tick >= pdMS_TO_TICKS(RESET_HOLD_TIME))
{
evse_set_available(false);
reset_and_reboot();
}
else
{
if (!(xEventGroupGetBits(wifi_event_group) & WIFI_AP_MODE_BIT))
{
led_set_buzzer();
wifi_ap_start();
// serial_mdb_set_meter_test(true);
}
}
}
pressed = false;
}
}
}
}
static void IRAM_ATTR button_isr_handler(void *arg)
{
BaseType_t higher_task_woken = pdFALSE;
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));
}
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_LOGE(TAG, "Failed to get partition %s information %s", conf->partition_label, esp_err_to_name(ret));
}
else
{
ESP_LOGI(TAG, "Partition %s size: total: %d, used: %d", conf->partition_label, total, used);
}
}
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_ERROR_CHECK(esp_vfs_spiffs_register(&cfg_conf));
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(&data_conf));
fs_info(&cfg_conf);
fs_info(&data_conf);
}
static bool ota_diagnostic(void)
{
// TODO diagnostic after ota
return true;
}
static void update_leds(void)
{
if (led_state != evse_get_state())
{
led_state = evse_get_state();
switch (led_state)
{
case EVSE_STATE_A:
led_set_off(LED_ID_CHARGING);
led_set_off(LED_ID_ERROR);
led_set_on(LED_ID_WIFI);
break;
case EVSE_STATE_B1:
case EVSE_STATE_B2:
led_set_off(LED_ID_ERROR);
led_set_off(LED_ID_WIFI);
led_set_on(LED_ID_CHARGING);
break;
case EVSE_STATE_C1:
case EVSE_STATE_D1:
led_set_off(LED_ID_ERROR);
led_set_off(LED_ID_WIFI);
led_set_state(LED_ID_CHARGING, 1000, 1000);
break;
case EVSE_STATE_C2:
case EVSE_STATE_D2:
led_set_off(LED_ID_ERROR);
led_set_off(LED_ID_WIFI);
led_set_state(LED_ID_CHARGING, 1000, 500);
led_set_buzzer();
break;
case EVSE_STATE_E:
led_set_off(LED_ID_WIFI);
led_set_off(LED_ID_CHARGING);
led_set_state(LED_ID_ERROR, 500, 500);
break;
case EVSE_STATE_F:
led_set_off(LED_ID_CHARGING);
led_set_off(LED_ID_WIFI);
led_set_state(LED_ID_ERROR, 500, 500);
break;
}
}
}
void app_main(void)
{
logger_init();
esp_log_set_vprintf(logger_vprintf);
const esp_partition_t *running = esp_ota_get_running_partition();
ESP_LOGI(TAG, "Running partition: %s", running->label);
esp_ota_img_states_t ota_state;
if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK)
{
if (ota_state == ESP_OTA_IMG_PENDING_VERIFY)
{
ESP_LOGI(TAG, "OTA pending verify");
if (ota_diagnostic())
{
ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution ...");
esp_ota_mark_app_valid_cancel_rollback();
}
else
{
ESP_LOGE(TAG, "Diagnostics failed! Start rollback to the previous version ...");
esp_ota_mark_app_invalid_rollback_and_reboot();
}
}
}
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();
peripherals_init();
api_init();
protocols_init();
evse_init();
button_init();
xTaskCreate(wifi_event_task_func, "wifi_event_task", 4 * 1024, NULL, 5, NULL);
xTaskCreate(user_input_task_func, "user_input_task", 4 * 1024, NULL, 5, &user_input_task);
// meter_init();
// ocpp_start();
// serial_mdb_start();
// currentshaper_start();
// initRc522();
// initWiegand();
// serial_mt_start();
// master_sync_start();
// slave_sync_start();
while (true)
{
evse_process();
update_leds();
// ESP_LOGI(TAG, "getPower %d", getDataMeter().wattA);
vTaskDelay(pdMS_TO_TICKS(100));
}
}