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

refact 3

Browse Source
This commit is contained in:
PlxEV
2025-06-08 16:55:50 +01:00
parent b457a39997
commit 03de00b93f
249 changed files with 93 additions and 19015 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/api/CMakeLists.txt
View File

@@ -9,6 +9,6 @@ idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include" "lib/cAT/src"
PRIV_INCLUDE_DIRS "src"
PRIV_REQUIRES nvs_flash app_update json driver esp_http_client esp_netif esp_wifi esp_timer esp_hw_support
REQUIRES network config evse peripherals protocols meter_orno_modbus ocpp)
REQUIRES network config evse peripherals protocols meter_orno ocpp)
set_source_files_properties(lib/cAT/src/cat.c PROPERTIES COMPILE_FLAGS -Wno-maybe-uninitialized)

16
components/api/src/json.c
View File

@@ -15,7 +15,6 @@
#include "evse_api.h"
#include "ocpp.h"
#include "board_config.h"
#include "meter.h"
#include "socket_lock.h"
#include "proximity.h"
//#include "modbus.h"
@@ -58,9 +57,9 @@ cJSON *json_get_evse_config(void)
cJSON_AddBoolToObject(root, "socketLockDetectionHigh", socket_lock_is_detection_high());
cJSON_AddNumberToObject(root, "socketLockRetryCount", socket_lock_get_retry_count());
cJSON_AddStringToObject(root, "modelMeter", meter_model_to_str(meter_get_model()));
cJSON_AddNumberToObject(root, "maxGridCurrent", grid_get_max_current());
cJSON_AddStringToObject(root, "stateMeter", meter_state_to_str(meter_get_state()));
//cJSON_AddStringToObject(root, "modelMeter", meter_model_to_str(meter_get_model()));
//cJSON_AddNumberToObject(root, "maxGridCurrent", grid_get_max_current());
//cJSON_AddStringToObject(root, "stateMeter", meter_state_to_str(meter_get_state()));
char str[64];
cJSON_AddBoolToObject(root, "enabledocpp", ocpp_get_enabled());
@@ -144,12 +143,12 @@ esp_err_t json_set_evse_config(cJSON *root)
socket_lock_set_retry_count(cJSON_GetObjectItem(root, "socketLockRetryCount")->valuedouble);
}
/*
if (cJSON_IsString(cJSON_GetObjectItem(root, "modelMeter")))
{
RETURN_ON_ERROR(meter_set_model(meter_str_to_model(cJSON_GetObjectItem(root, "modelMeter")->valuestring)));
}
/*
if (cJSON_IsString(cJSON_GetObjectItem(root, "stateMeter")))
{
RETURN_ON_ERROR(meter_set_state(meter_str_to_state(cJSON_GetObjectItem(root, "stateMeter")->valuestring)));
@@ -379,6 +378,7 @@ cJSON *json_get_state(void)
cJSON_AddItemToObject(root, "errors", errors);
}
/*
cJSON_AddNumberToObject(root, "sessionTime", energy_meter_get_session_time());
cJSON_AddNumberToObject(root, "chargingTime", energy_meter_get_charging_time());
cJSON_AddNumberToObject(root, "consumption", energy_meter_get_consumption());
@@ -388,6 +388,7 @@ cJSON *json_get_state(void)
cJSON_AddItemToObject(root, "voltage", cJSON_CreateFloatArray(values, 3));
energy_meter_get_current(values);
cJSON_AddItemToObject(root, "current", cJSON_CreateFloatArray(values, 3));
*/
return root;
}
@@ -456,6 +457,8 @@ cJSON *json_get_board_config(void)
cJSON_AddNumberToObject(root, "socketLockMinBreakTime", board_config.socket_lock_min_break_time);
cJSON_AddBoolToObject(root, "rcm", board_config.rcm);
cJSON_AddBoolToObject(root, "temperatureSensor", board_config.onewire && board_config.onewire_temp_sensor);
/*
switch (board_config.energy_meter)
{
case BOARD_CONFIG_ENERGY_METER_CUR:
@@ -467,7 +470,8 @@ cJSON *json_get_board_config(void)
default:
cJSON_AddStringToObject(root, "energyMeter", "none");
}
cJSON_AddBoolToObject(root, "energyMeterThreePhases", board_config.energy_meter_three_phases);
//cJSON_AddBoolToObject(root, "energyMeterThreePhases", board_config.energy_meter_three_phases);
*/
cJSON_AddStringToObject(root, "serial1", serial_to_str(board_config.serial_1));
cJSON_AddStringToObject(root, "serial1Name", board_config.serial_1_name);

6
components/evse/evse_core.c
View File

@@ -6,7 +6,6 @@
#include "evse_config.h"
#include "evse_api.h"
#include "pilot.h"
#include "meter.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "esp_log.h"
@@ -69,11 +68,6 @@ void evse_process(void) {
}
xSemaphoreGive(mutex);
energy_meter_process(
evse_state_is_charging(evse_get_state()),
evse_get_charging_current()
);
}
// ================================

5
components/evse/evse_fsm.c
View File

@@ -7,7 +7,6 @@
#include "ac_relay.h"
#include "board_config.h"
#include "socket_lock.h"
#include "meter.h"
#include "proximity.h"
#include "rcm.h"
#include "evse_state.h"
@@ -37,7 +36,7 @@ static void update_outputs(evse_state_t state, uint16_t charging_current, uint8_
if (board_config.socket_lock && socket_outlet) {
socket_lock_set_locked(false);
}
energy_meter_stop_session();
//energy_meter_stop_session();
break;
case EVSE_STATE_B1:
@@ -57,7 +56,7 @@ static void update_outputs(evse_state_t state, uint16_t charging_current, uint8_
cable_max_current = proximity_get_max_current();
}
energy_meter_start_session();
//energy_meter_start_session();
break;
case EVSE_STATE_B2:

10
components/evse/evse_hardware.c
View File

@@ -3,7 +3,6 @@
#include "ac_relay.h"
#include "socket_lock.h"
#include "proximity.h"
#include "meter.h"
static const char *TAG = "evse_hardware";
@@ -27,14 +26,7 @@ bool evse_hardware_is_vehicle_connected(void) {
}
bool evse_hardware_is_energy_detected(void) {
if (!meter_is_running()) {
return false;
}
MeterData data = meter_getData();
const float THRESHOLD = 0.1f; // Corrente mínima para considerar consumo
return (data.irmsA > THRESHOLD) || (data.irmsB > THRESHOLD) ||
(data.irmsC > THRESHOLD);
return false;
}
void evse_hardware_relay_on(void) {

2
components/evsemeter/CMakeLists.txt
View File

@@ -6,4 +6,4 @@ set(srcs
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
REQUIRES esp_event meter_orno_modbus ade7758)
REQUIRES esp_event meter_orno meter_ade7758)

2
components/gridmeter/CMakeLists.txt
View File

@@ -5,4 +5,4 @@ set(srcs
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
REQUIRES esp_event meter_orno_modbus)
REQUIRES esp_event meter_orno meter_zigbee)

2
components/ade7758/CMakeLists.txt → components/meter_ade7758/CMakeLists.txt
View File

@@ -6,5 +6,5 @@ idf_component_register(
INCLUDE_DIRS
"include"
REQUIRES
driver evse nvs_flash esp_timer meter_orno_modbus
driver evse nvs_flash esp_timer
)

0
components/ade7758/include/ade7758.h → components/meter_ade7758/include/ade7758.h
View File

0
components/ade7758/include/meter.h → components/meter_ade7758/include/meter.h
View File

0
components/ade7758/src/ade7758.c → components/meter_ade7758/src/ade7758.c
View File

0
components/ade7758/src/energy_meter.c → components/meter_ade7758/src/energy_meter.c
View File

0
components/ade7758/src/meter.c → components/meter_ade7758/src/meter.c
View File

0
components/meter_orno_modbus/CMakeLists.txt → components/meter_orno/CMakeLists.txt
View File

0
components/meter_orno_modbus/include/orno_modbus.h → components/meter_orno/include/orno_modbus.h
View File

0
components/meter_orno_modbus/src/orno_modbus.c → components/meter_orno/src/orno_modbus.c
View File

3
components/meter_zigbee/CMakeLists.txt
View File

@@ -4,5 +4,4 @@ set(srcs
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
PRIV_REQUIRES driver
REQUIRES config evse loadbalancer serial_sync)
PRIV_REQUIRES driver)

188
components/meter_zigbee/src/meter_zigbee.c
View File

@@ -1,4 +1,3 @@
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
@@ -7,171 +6,104 @@
#include "string.h"
#include "driver/gpio.h"
#include "meter_zigbee.h"
#include "evse_api.h"
#include "loadbalancer.h"
#include "meter.h"
//#include "app_main.h"
//#include "sync_master.h"
#include <math.h>
#define BUF_SIZE 128
#define TAG "meter_zigbee"
#define TXD_PIN (GPIO_NUM_17)
#define RXD_PIN (GPIO_NUM_16)
#define BUF_SIZE 128
#define RX_BUF_SIZE 14
#define VOLTAGE_CURRENT1_ATTR 0x0006
#define VOLTAGE_CURRENT2_ATTR 0x0007
#define VOLTAGE_CURRENT3_ATTR 0x0008
// static uint8_t msg[128];
static const char *TAG = "meter_zigbee";
static uart_port_t port = -1;
static TaskHandle_t meter_zigbee_task = NULL;
static float l1_current = 0, l2_current = 0, l3_current = 0;
static const int RX_BUF_SIZE = 14;
static float decode_current(const uint8_t *buf) {
return (buf[9] + (buf[8] << 8) + (buf[7] << 16)) / 100.0f;
}
static void meter_zigbee_task_func(void *param)
{
ESP_LOGI(TAG, "meter_zigbee_task_func");
static void decode_frame(const uint8_t *buf) {
uint16_t attr_code = buf[1] | (buf[2] << 8);
uint8_t size = buf[4];
uint8_t *buff = (uint8_t *)malloc(RX_BUF_SIZE + 1);
if (size != 8) {
ESP_LOGW(TAG, "Unexpected data size: %d", size);
return;
}
unsigned long currentMillis = pdTICKS_TO_MS(xTaskGetTickCount()) - 120000;
float current = decode_current(buf);
ESP_LOGI(TAG, "Attr 0x%04X - Current: %.2f A", attr_code, current);
while (1)
{
const int rxBytes = uart_read_bytes(UART_NUM_1, buff, RX_BUF_SIZE, 1000 / portTICK_PERIOD_MS);
if (rxBytes >= 10)
{
//ESP_LOGI(TAG, "Read %d bytes: '%s'", rxBytes, buff);
//ESP_LOG_BUFFER_HEXDUMP(TAG, buff, rxBytes, ESP_LOG_INFO);
switch (attr_code) {
case VOLTAGE_CURRENT1_ATTR: l1_current = current; break;
case VOLTAGE_CURRENT2_ATTR: l2_current = current; break;
case VOLTAGE_CURRENT3_ATTR: l3_current = current; break;
default:
ESP_LOGW(TAG, "Unknown attribute code: 0x%04X", attr_code);
return;
}
uint8_t idmsg = buff[0];
uint16_t code = buff[1] + (buff[2] << 8);
uint8_t size = buff[4];
uint32_t power = 0;
uint32_t current = 0;
uint32_t volt = 0;
float max_current = fmaxf(fmaxf(l1_current, l2_current), l3_current);
ESP_LOGI(TAG, "Max current: %.2f A", max_current);
}
float maxcurrent = 0;
float l1current = 0;
float l2current = 0;
float l3current = 0;
static void meter_zigbee_task_func(void *param) {
ESP_LOGI(TAG, "Zigbee meter task started");
uint8_t *buf = malloc(RX_BUF_SIZE);
if (!buf) {
ESP_LOGE(TAG, "Memory allocation failed");
vTaskDelete(NULL);
return;
}
//ESP_LOGI(TAG, "Msg id: %d code 0x%04hx size %d ", idmsg, code, size);
if (size == 8)
{
power = buff[12] + (buff[11] << 8) + (buff[10] << 16); // + (buff[9] << 24);
ESP_LOGI(TAG, "VOLTAGE_CURRENT_ATTR Power value %" PRIu32 " ", power);
current = buff[9] + (buff[8] << 8) + (buff[7] << 16); // + (buff[9] << 24);
ESP_LOGI(TAG, "VOLTAGE_CURRENT_ATTR Current value %" PRIu32 " ", current);
volt = buff[6] + (buff[5] << 8); // + (buff[4] << 16);// + (buff[9] << 24);
ESP_LOGI(TAG, "VOLTAGE_CURRENT_ATTR Voltage value %" PRIu32 " ", volt);
if (code == VOLTAGE_CURRENT1_ATTR)
{
l1current = current / 100.0f;
}
else if (code == VOLTAGE_CURRENT2_ATTR)
{
l2current = current / 100.0f;
}
else if (code == VOLTAGE_CURRENT3_ATTR)
{
l3current = current / 100.0f;
}
else
{
ESP_LOGW(TAG, "Error code %d ", code);
// continue;
}
maxcurrent = (l1current > l2current) ? l1current : l2current;
maxcurrent = (maxcurrent > l3current) ? maxcurrent : l3current;
ESP_LOGI(TAG, "maxcurrent value %f ", maxcurrent);
//send_grid_current(maxcurrent);
if (evse_state_is_charging(evse_get_state()))
{
setMaxGridCurrent(grid_get_max_current() * 10);
setLiveGridCurrent((int)maxcurrent);
/*
if (pdTICKS_TO_MS(xTaskGetTickCount()) - currentMillis > 120000)
{
push_grid_power(power / 1000.0f);
push_grid_current(l1current / 10.0f);
push_grid_volt(volt / 10.0f);
currentMillis = pdTICKS_TO_MS(xTaskGetTickCount());
}*/
}
}
while (1) {
int len = uart_read_bytes(UART_NUM_1, buf, RX_BUF_SIZE, pdMS_TO_TICKS(1000));
if (len >= 10) {
decode_frame(buf);
}
}
free(buff);
free(buf);
vTaskDelete(NULL);
}
int meter_zigbee_send_data(const char *data)
{
const int len = strlen(data);
const int txBytes = uart_write_bytes(UART_NUM_1, data, len);
ESP_LOGI(TAG, "Wrote %d bytes", txBytes);
return txBytes;
int meter_zigbee_send_data(const char *data) {
int len = strlen(data);
int sent = uart_write_bytes(UART_NUM_1, data, len);
ESP_LOGI(TAG, "Sent %d bytes", sent);
return sent;
}
void meter_zigbee_start()
{
void meter_zigbee_start(void) {
ESP_LOGI(TAG, "Starting Zigbee UART");
ESP_LOGI(TAG, "Starting MT Serial");
const uart_config_t uart_config = {
uart_config_t uart_config = {
.baud_rate = 115200,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.source_clk = UART_SCLK_DEFAULT,
.source_clk = UART_SCLK_DEFAULT
};
esp_err_t err = uart_param_config(UART_NUM_1, &uart_config);
if (err != ESP_OK)
{
ESP_LOGE(TAG, "uart_param_config() returned 0x%x", err);
return;
}
err = uart_driver_install(UART_NUM_1, BUF_SIZE * 2, 0, 0, NULL, 0);
if (err != ESP_OK)
{
ESP_LOGE(TAG, "uart_driver_install() returned 0x%x", err);
return;
}
ESP_ERROR_CHECK(uart_param_config(UART_NUM_1, &uart_config));
ESP_ERROR_CHECK(uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
ESP_ERROR_CHECK(uart_driver_install(UART_NUM_1, BUF_SIZE * 2, 0, 0, NULL,0));
// xTaskCreate(rx_task, "uart_rx_task", 1024 * 4, NULL, configMAX_PRIORITIES, NULL);
xTaskCreate(meter_zigbee_task_func, "meter_zigbee_task", 4 * 1024, NULL, 5, &meter_zigbee_task);
xTaskCreate(meter_zigbee_task_func, "meter_zigbee_task", 4096, NULL, 5, &meter_zigbee_task);
}
void meter_zigbee_stop(void)
{
ESP_LOGI(TAG, "Stopping");
void meter_zigbee_stop(void) {
ESP_LOGI(TAG, "Stopping Zigbee UART");
if (meter_zigbee_task)
{
if (meter_zigbee_task) {
vTaskDelete(meter_zigbee_task);
meter_zigbee_task = NULL;
}
if (port != -1)
{
uart_driver_delete(port);
port = -1;
}
}
uart_driver_delete(UART_NUM_1);
}

8
components/modbus/CMakeLists.txt
View File

@@ -1,8 +0,0 @@
set(srcs
"src/modbus.c")
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
PRIV_INCLUDE_DIRS "src"
PRIV_REQUIRES nvs_flash app_update driver esp_timer
REQUIRES config evse peripherals)

17
components/modbus/idf_component.yml
View File

@@ -1,17 +0,0 @@
## IDF Component Manager Manifest File
dependencies:
espressif/esp-modbus: "^1.0.16"
## Required IDF version
idf:
version: ">=4.1.0"
# # Put list of dependencies here
# # For components maintained by Espressif:
# component: "~1.0.0"
# # For 3rd party components:
# username/component: ">=1.0.0,<2.0.0"
# username2/component2:
# version: "~1.0.0"
# # For transient dependencies `public` flag can be set.
# # `public` flag doesn't have an effect dependencies of the `main` component.
# # All dependencies of `main` are public by default.
# public: true

42
components/modbus/include/modbus.h
View File

@@ -1,42 +0,0 @@
#ifndef MODBUS_H_
#define MODBUS_H_
#define MODBUS_PACKET_SIZE 256
#define MODBUS_READ_UINT16(buf, offset) ((uint16_t)(buf[offset] << 8 | buf[offset + 1]))
#define MODBUS_WRITE_UINT16(buf, offset, value) \
buf[offset] = value >> 8; \
buf[offset + 1] = value & 0xFF; \
#include "esp_err.h"
/**
* @brief Initialize modbus
*
*/
void modbus_init(void);
/**
* @brief Process modbus request
*
* @param buf Request/response data
* @param len Length of request data
* @return uint16_t Length of response data, 0 if no response
*/
uint16_t modbus_request_exec(uint8_t *buf, uint16_t len);
/**
* @brief Get modbus unit id
*
* @return uint8_t
*/
uint8_t modbus_get_unit_id(void);
/**
* @brief Set modbus unit id
*
* @param unit_id
*/
esp_err_t modbus_set_unit_id(uint8_t unit_id);
#endif /* MODBUS_H_ */

508
components/modbus/src/modbus.c
View File

@@ -1,508 +0,0 @@
#include <string.h>
#include <math.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_ota_ops.h"
#include "nvs.h"
#include "modbus.h"
#include "evse_api.h"
#include "evse_error.h"
#include "meter.h"
#include "socket_lock.h"
#include "temp_sensor.h"
#define MODBUS_REG_STATE 100
#define MODBUS_REG_ERROR 101 // 2 word
#define MODBUS_REG_ENABLED 103
#define MODBUS_REG_AVAILABLE 104
#define MODBUS_REG_PENDING_AUTH 105
#define MODBUS_REG_CHR_CURRENT 106
#define MODBUS_REG_CONSUMPTION_LIM 107 // 2 word
#define MODBUS_REG_CHR_TIME_LIM 109 // 2 word
#define MODBUS_REG_UNDER_POWER_LIM 111
#define MODBUS_REG_AUTHORISE 112
#define MODBUS_REG_EMETER_POWER 200
#define MODBUS_REG_EMETER_SES_TIME 201 // 2 word
#define MODBUS_REG_EMETER_CHR_TIME 203 // 2 word
#define MODBUS_REG_EMETER_CONSUMPTION 205 // 2 word
#define MODBUS_REG_EMETER_L1_VTL 207 // 2 word
#define MODBUS_REG_EMETER_L2_VTL 209 // 2 word
#define MODBUS_REG_EMETER_L3_VTL 211 // 2 word
#define MODBUS_REG_EMETER_L1_CUR 213 // 2 word
#define MODBUS_REG_EMETER_L2_CUR 215 // 2 word
#define MODBUS_REG_EMETER_L3_CUR 217 // 2 word
#define MODBUS_REG_SOCKET_OUTLET 300
#define MODBUS_REG_RCM 301
#define MODBUS_REG_TEMP_THRESHOLD 302
#define MODBUS_REG_REQ_AUTH 303
#define MODBUS_REG_MAX_CHR_CURRENT 304
#define MODBUS_REG_DEF_CHR_CURRENT 305
#define MODBUS_REG_DEF_CONSUMPTION_LIM 306 //2 word
#define MODBUS_REG_DEF_CHR_TIME_LIM 308 //2 word
#define MODBUS_REG_DEF_UNDER_POWER_LIM 310
#define MODBUS_REG_LOCK_OPERATING_TIME 311
#define MODBUS_REG_LOCK_BRAKE_TIME 312
#define MODBUS_REG_LOCK_DET_HI 313
#define MODBUS_REG_LOCK_RET_COUNT 314
#define MODBUS_REG_EMETER_MODE 315
#define MODBUS_REG_EMETER_AC_VLT 316
#define MODBUS_REG_UPTIME 400 //2 word
#define MODBUS_REG_TEMP_LOW 402
#define MODBUS_REG_TEMP_HIGH 403
#define MODBUS_REG_TEMP_SENSOR_COUNT 404
#define MODBUS_REG_APP_VERSION 405 //16 word
#define MODBUS_REG_RESTART 421
#define MODBUS_EX_NONE 0x00
#define MODBUS_EX_ILLEGAL_FUNCTION 0x01
#define MODBUS_EX_ILLEGAL_DATA_ADDRESS 0x02
#define MODBUS_EX_ILLEGAL_DATA_VALUE 0x03
#define MODBUS_EX_SLAVE_DEVICE_FAILURE 0x04
#define MODBUS_EX_ACKNOWLEDGE 0x05
#define MODBUS_EX_SLAVE_BUSY 0x06
#define MODBUS_EX_MEMORY_PARITY_ERROR 0x08
#define UINT32_GET_HI(value) ((uint16_t)(((uint32_t) (value)) >> 16))
#define UINT32_GET_LO(value) ((uint16_t)(((uint32_t) (value)) & 0xFFFF))
#define NVS_NAMESPACE "modbus"
#define NVS_UNIT_ID "unit_id"
static const char* TAG = "modbus";
static nvs_handle nvs;
static uint8_t unit_id = 1;
static void restart_func(void* arg)
{
vTaskDelay(pdMS_TO_TICKS(5000));
esp_restart();
vTaskDelete(NULL);
}
static void timeout_restart()
{
xTaskCreate(restart_func, "restart_task", 2 * 1024, NULL, 10, NULL);
}
void modbus_init(void)
{
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
nvs_get_u8(nvs, NVS_UNIT_ID, &unit_id);
}
static uint32_t get_uptime(void)
{
return esp_timer_get_time() / 1000000;
}
static bool read_holding_register(uint16_t addr, uint16_t* value)
{
ESP_LOGD(TAG, "HR read %d", addr);
switch (addr) {
case MODBUS_REG_STATE:
const char* state_str = evse_state_to_str(evse_get_state());
*value = state_str[0] << 8 | state_str[1];
break;
case MODBUS_REG_ERROR:
*value = UINT32_GET_HI(evse_get_error());
break;
case MODBUS_REG_ERROR + 1:
*value = UINT32_GET_LO(evse_get_error());
break;
case MODBUS_REG_ENABLED:
*value = evse_is_enabled();
break;
case MODBUS_REG_AVAILABLE:
*value = evse_is_enabled();
break;
case MODBUS_REG_PENDING_AUTH:
*value = evse_is_pending_auth();
break;
case MODBUS_REG_CHR_CURRENT:
*value = evse_get_charging_current();
break;
case MODBUS_REG_CONSUMPTION_LIM:
*value = UINT32_GET_HI(evse_get_consumption_limit());
break;
case MODBUS_REG_CONSUMPTION_LIM + 1:
*value = UINT32_GET_LO(evse_get_consumption_limit());
break;
case MODBUS_REG_CHR_TIME_LIM:
*value = UINT32_GET_HI(evse_get_charging_time_limit());
break;
case MODBUS_REG_CHR_TIME_LIM + 1:
*value = UINT32_GET_LO(evse_get_charging_time_limit());
break;
case MODBUS_REG_UNDER_POWER_LIM:
*value = evse_get_under_power_limit();
break;
case MODBUS_REG_EMETER_POWER:
*value = energy_meter_get_power();
break;
case MODBUS_REG_EMETER_SES_TIME:
*value = UINT32_GET_HI(energy_meter_get_session_time());
break;
case MODBUS_REG_EMETER_SES_TIME + 1:
*value = UINT32_GET_LO(energy_meter_get_session_time());
break;
case MODBUS_REG_EMETER_CHR_TIME:
*value = UINT32_GET_HI(energy_meter_get_charging_time());
break;
case MODBUS_REG_EMETER_CHR_TIME + 1:
*value = UINT32_GET_LO(energy_meter_get_charging_time());
break;
case MODBUS_REG_EMETER_CONSUMPTION:
*value = UINT32_GET_HI(energy_meter_get_consumption());
break;
case MODBUS_REG_EMETER_CONSUMPTION + 1:
*value = UINT32_GET_LO(energy_meter_get_consumption());
break;
case MODBUS_REG_EMETER_L1_VTL:
*value = UINT32_GET_HI(energy_meter_get_l1_voltage() * 1000);
break;
case MODBUS_REG_EMETER_L1_VTL + 1:
*value = UINT32_GET_LO(energy_meter_get_l1_voltage() * 1000);
break;
case MODBUS_REG_EMETER_L2_VTL:
*value = UINT32_GET_HI(energy_meter_get_l2_voltage() * 1000);
break;
case MODBUS_REG_EMETER_L2_VTL + 1:
*value = UINT32_GET_LO(energy_meter_get_l2_voltage() * 1000);
break;
case MODBUS_REG_EMETER_L3_VTL:
*value = UINT32_GET_HI(energy_meter_get_l3_voltage() * 1000);
break;
case MODBUS_REG_EMETER_L3_VTL + 1:
*value = UINT32_GET_LO(energy_meter_get_l3_voltage() * 1000);
break;
case MODBUS_REG_EMETER_L1_CUR:
*value = UINT32_GET_HI(energy_meter_get_l1_current() * 1000);
break;
case MODBUS_REG_EMETER_L1_CUR + 1:
*value = UINT32_GET_LO(energy_meter_get_l1_current() * 1000);
break;
case MODBUS_REG_EMETER_L2_CUR:
*value = UINT32_GET_HI(energy_meter_get_l2_current() * 1000);
break;
case MODBUS_REG_EMETER_L2_CUR + 1:
*value = UINT32_GET_LO(energy_meter_get_l2_current() * 1000);
break;
case MODBUS_REG_EMETER_L3_CUR:
*value = UINT32_GET_HI(energy_meter_get_l3_current() * 1000);
break;
case MODBUS_REG_EMETER_L3_CUR + 1:
*value = UINT32_GET_LO(energy_meter_get_l3_current() * 1000);
break;
case MODBUS_REG_SOCKET_OUTLET:
*value = evse_get_socket_outlet();
break;
case MODBUS_REG_RCM:
*value = evse_is_rcm();
break;
case MODBUS_REG_TEMP_THRESHOLD:
*value = evse_get_temp_threshold();
break;
case MODBUS_REG_REQ_AUTH:
*value = evse_is_require_auth();
break;
case MODBUS_REG_MAX_CHR_CURRENT:
*value = evse_get_max_charging_current();
break;
case MODBUS_REG_DEF_CHR_CURRENT:
*value = evse_get_default_charging_current();
break;
case MODBUS_REG_DEF_CONSUMPTION_LIM:
*value = UINT32_GET_HI(evse_get_default_consumption_limit());
break;
case MODBUS_REG_DEF_CONSUMPTION_LIM + 1:
*value = UINT32_GET_LO(evse_get_default_consumption_limit());
break;
case MODBUS_REG_DEF_CHR_TIME_LIM:
*value = UINT32_GET_HI(evse_get_default_charging_time_limit());
break;
case MODBUS_REG_DEF_CHR_TIME_LIM + 1:
*value = UINT32_GET_LO(evse_get_default_charging_time_limit());
break;
case MODBUS_REG_DEF_UNDER_POWER_LIM:
*value = evse_get_default_under_power_limit();
break;
case MODBUS_REG_LOCK_OPERATING_TIME:
*value = socket_lock_get_operating_time();
break;
case MODBUS_REG_LOCK_BRAKE_TIME:
*value = socket_lock_get_break_time();
break;
case MODBUS_REG_LOCK_DET_HI:
*value = socket_lock_is_detection_high();
break;
case MODBUS_REG_LOCK_RET_COUNT:
*value = socket_lock_get_retry_count();
break;
//case MODBUS_REG_EMETER_MODE:
// *value = energy_meter_get_mode();
// break;
//case MODBUS_REG_EMETER_AC_VLT:
// *value = energy_meter_get_ac_voltage();
// break;
case MODBUS_REG_UPTIME:
*value = UINT32_GET_HI(get_uptime());
break;
case MODBUS_REG_UPTIME + 1:
*value = UINT32_GET_LO(get_uptime());
break;
case MODBUS_REG_TEMP_LOW:
*value = temp_sensor_get_low();
break;
case MODBUS_REG_TEMP_HIGH:
*value = temp_sensor_get_high();
break;
case MODBUS_REG_TEMP_SENSOR_COUNT:
*value = temp_sensor_get_count();
break;
default:
//string registers
if (addr >= MODBUS_REG_APP_VERSION && addr <= MODBUS_REG_APP_VERSION + 16) {
const esp_app_desc_t* app_desc = esp_app_get_description();
*value = app_desc->version[(addr - MODBUS_REG_APP_VERSION) * 2] << 8 | app_desc->version[(addr - MODBUS_REG_APP_VERSION) * 2 + 1];
} else {
return MODBUS_EX_ILLEGAL_DATA_ADDRESS;
}
}
return MODBUS_EX_NONE;
}
static bool write_holding_register(uint16_t addr, uint8_t* buffer, uint16_t left)
{
uint16_t value = MODBUS_READ_UINT16(buffer, 0);
ESP_LOGD(TAG, "HR write %d = %d", addr, value);
switch (addr) {
case MODBUS_REG_ENABLED:
if (value > 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
evse_set_enabled(value);
break;
case MODBUS_REG_AVAILABLE:
if (value > 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
evse_set_available(value);
break;
case MODBUS_REG_CHR_CURRENT:
if (evse_set_charging_current(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_CONSUMPTION_LIM:
if (left > 0) {
evse_set_consumption_limit(value << 16 | MODBUS_READ_UINT16(buffer, 2));
} else {
return MODBUS_EX_ILLEGAL_DATA_ADDRESS;
}
break;
case MODBUS_REG_CONSUMPTION_LIM + 1:
break;
case MODBUS_REG_CHR_TIME_LIM:
if (left > 0) {
evse_set_charging_time_limit(value << 16 | MODBUS_READ_UINT16(buffer, 2));
} else {
return MODBUS_EX_ILLEGAL_DATA_ADDRESS;
}
break;
case MODBUS_REG_CHR_TIME_LIM + 1:
break;
case MODBUS_REG_UNDER_POWER_LIM:
evse_set_under_power_limit(value);
break;
case MODBUS_REG_AUTHORISE:
if (value != 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
evse_authorize();
break;
case MODBUS_REG_SOCKET_OUTLET:
if (value != 0 || value != 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
if (evse_set_socket_outlet(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_RCM:
if (value != 0 || value != 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
if (evse_set_rcm(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_TEMP_THRESHOLD:
if (evse_set_temp_threshold(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_REQ_AUTH:
if (value != 0 || value != 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
evse_set_require_auth(value);
break;
case MODBUS_REG_MAX_CHR_CURRENT:
if (evse_set_max_charging_current(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_DEF_CHR_CURRENT:
if (evse_set_default_charging_current(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_DEF_CONSUMPTION_LIM:
if (left > 0) {
evse_set_default_consumption_limit(value << 16 | MODBUS_READ_UINT16(buffer, 2));
} else {
return MODBUS_EX_ILLEGAL_DATA_ADDRESS;
}
break;
case MODBUS_REG_DEF_CONSUMPTION_LIM + 1:
break;
case MODBUS_REG_DEF_CHR_TIME_LIM:
if (left > 0) {
evse_set_default_charging_time_limit(value << 16 | MODBUS_READ_UINT16(buffer, 2));
} else {
return MODBUS_EX_ILLEGAL_DATA_ADDRESS;
}
break;
case MODBUS_REG_DEF_CHR_TIME_LIM + 1:
break;
case MODBUS_REG_DEF_UNDER_POWER_LIM:
evse_set_default_under_power_limit(value);
break;
case MODBUS_REG_LOCK_OPERATING_TIME:
if (socket_lock_set_operating_time(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_LOCK_BRAKE_TIME:
if (socket_lock_set_break_time(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_LOCK_DET_HI:
if (value != 0 || value != 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
socket_lock_set_detection_high(value);
break;
case MODBUS_REG_LOCK_RET_COUNT:
if (value > UINT8_MAX) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
socket_lock_set_retry_count(value);
break;
/*
case MODBUS_REG_EMETER_MODE:
if (energy_meter_set_mode(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
case MODBUS_REG_EMETER_AC_VLT:
if (energy_meter_set_ac_voltage(value) != ESP_OK) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
break;
*/
case MODBUS_REG_RESTART:
if (value != 1) {
return MODBUS_EX_ILLEGAL_DATA_VALUE;
}
timeout_restart();
break;
default:
return MODBUS_EX_ILLEGAL_DATA_ADDRESS;
}
return MODBUS_EX_NONE;
}
uint16_t modbus_request_exec(uint8_t* data, uint16_t len)
{
uint16_t resp_len = 0;
if (unit_id == data[0]) {
uint8_t fc = data[1];
uint16_t addr;
uint16_t count;
uint16_t value;
uint8_t ex = MODBUS_EX_NONE;
if (fc == 3) {
addr = MODBUS_READ_UINT16(data, 2);
count = MODBUS_READ_UINT16(data, 4);
data[2] = count * 2;
resp_len = 3 + count * 2;
for (uint16_t i = 0; i < count; i++) {
if ((ex = read_holding_register(addr + i, &value)) != MODBUS_EX_NONE) {
break;
}
MODBUS_WRITE_UINT16(data, 3 + 2 * i, value);
}
} else if (fc == 6) {
addr = MODBUS_READ_UINT16(data, 2);
resp_len = 6;
ex = write_holding_register(addr, &data[4], 0);
} else if (fc == 16) {
addr = MODBUS_READ_UINT16(data, 2);
count = MODBUS_READ_UINT16(data, 4);
resp_len = 6;
for (uint16_t i = 0; i < count; i++) {
if ((ex = write_holding_register(addr + i, &data[7 + 2 * i], count - i)) != MODBUS_EX_NONE) {
break;
}
}
} else {
ex = MODBUS_EX_ILLEGAL_FUNCTION;
}
if (ex != MODBUS_EX_NONE) {
data[1] = 0x8 | fc;
data[2] = ex;
resp_len = 3;
}
}
return resp_len;
}
uint8_t modbus_get_unit_id(void)
{
return unit_id;
}
esp_err_t modbus_set_unit_id(uint8_t _unit_id)
{
if (_unit_id == 0) {
ESP_LOGE(TAG, "Unit id cant be 0");
return ESP_ERR_INVALID_ARG;
}
unit_id = _unit_id;
nvs_set_u8(nvs, NVS_UNIT_ID, unit_id);
return ESP_OK;
}

2
components/ocpp/CMakeLists.txt
View File

@@ -5,4 +5,4 @@ set(srcs
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
PRIV_REQUIRES nvs_flash
REQUIRES config esp_wifi evse ade7758 mongoose MicroOcpp MicroOcppMongoose)
REQUIRES config esp_wifi evse mongoose MicroOcpp MicroOcppMongoose)

26
components/ocpp/src/ocpp.c
View File

@@ -6,7 +6,6 @@
#include "evse_state.h"
#include "esp_wifi.h"
#include "meter.h"
#include "orno_modbus.h"
#include "nvs.h"
@@ -149,22 +148,12 @@ bool setEvseReadyInput()
// return false;
}
#include "meter.h"
#include "esp_log.h"
#define TAG "ocpp_input" // ou o nome adequado do seu módulo
float setPowerMeterInput()
{
ESP_LOGI(TAG, "PowerMeterInput");
if (!meter_is_running()) {
ESP_LOGW(TAG, "Meter not running, returning fallback value.");
return 0.0f;
}
MeterData data = meter_getData();
return data.wattA + data.wattB + data.wattC;
//MeterData data = meter_getData();
//return data.wattA + data.wattB + data.wattC;
return 0.0f;
}
float setEnergyMeterInput()
@@ -187,6 +176,7 @@ float setCurrentInput()
{
ESP_LOGI(TAG, "CurrentInput");
/*
if (!meter_is_running()) {
ESP_LOGW(TAG, "Meter not running, returning fallback.");
return 0.0f;
@@ -194,12 +184,15 @@ float setCurrentInput()
MeterData data = meter_getData();
return data.irmsA;
*/
return 0;
}
float setVoltageInput()
{
ESP_LOGI(TAG, "VoltageInput");
/*
if (!meter_is_running()) {
ESP_LOGW(TAG, "Meter not running, returning fallback.");
return 0.0f;
@@ -207,6 +200,8 @@ float setVoltageInput()
MeterData data = meter_getData();
return data.vrmsA;
*/
return 0.0f;
}
float setTemperatureInput()
@@ -219,7 +214,8 @@ float setPowerInput()
{
ESP_LOGI(TAG, "PowerInput");
// return (float)orno_modbus_get_meter_state().activepower;
return meter_getData().wattA + meter_getData().wattB + meter_getData().wattC;
//return meter_getData().wattA + meter_getData().wattB + meter_getData().wattC;
return 0;
}
void setSmartChargingCurrentOutput(float limit)

2
components/peripherals/CMakeLists.txt
View File

@@ -19,4 +19,4 @@ set(srcs
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
PRIV_REQUIRES nvs_flash driver esp_adc esp_timer
REQUIRES config evse api ade7758 ntc_driver)
REQUIRES config evse api ntc_driver)

3
components/peripherals/src/peripherals.c
View File

@@ -7,7 +7,6 @@
#include "ac_relay.h"
#include "socket_lock.h"
#include "rcm.h"
#include "meter.h"
#include "aux_io.h"
#include "ntc_sensor.h"
@@ -21,7 +20,7 @@ void peripherals_init(void)
proximity_init();
// socket_lock_init();
// rcm_init();
energy_meter_init();
//energy_meter_init();
// aux_init();
ntc_sensor_init();
}