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

534
components/api/src/json.c Executable file
View File

@@ -0,0 +1,534 @@
#include <string.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "esp_wifi.h"
#include "esp_ota_ops.h"
#include "esp_timer.h"
#include "esp_chip_info.h"
#include "esp_mac.h"
#include "json.h"
#include "mqtt.h"
#include "wifi.h"
#include "timeout_utils.h"
#include "evse_error.h"
#include "evse_api.h"
#include "ocpp.h"
#include "board_config.h"
#include "energy_meter.h"
#include "socket_lock.h"
#include "proximity.h"
//#include "modbus.h"
//#include "modbus_tcp.h"
#include "rest.h"
#include "temp_sensor.h"
// #include "script.h"
#include "date_time.h"
#define RETURN_ON_ERROR(x) \
do \
{ \
esp_err_t err_rc_ = (x); \
if (unlikely(err_rc_ != ESP_OK)) \
{ \
return err_rc_; \
} \
} while (0)
cJSON *json_get_evse_config(void)
{
cJSON *root = cJSON_CreateObject();
cJSON_AddNumberToObject(root, "maxChargingCurrent", evse_get_max_charging_current());
cJSON_AddNumberToObject(root, "chargingCurrent", evse_get_charging_current() / 10.0);
cJSON_AddNumberToObject(root, "defaultChargingCurrent", evse_get_default_charging_current() / 10.0);
cJSON_AddBoolToObject(root, "requireAuth", evse_is_require_auth());
cJSON_AddBoolToObject(root, "socketOutlet", evse_get_socket_outlet());
cJSON_AddBoolToObject(root, "rcm", evse_is_rcm());
cJSON_AddNumberToObject(root, "temperatureThreshold", evse_get_temp_threshold());
cJSON_AddNumberToObject(root, "consumptionLimit", evse_get_consumption_limit());
cJSON_AddNumberToObject(root, "defaultConsumptionLimit", evse_get_default_consumption_limit());
cJSON_AddNumberToObject(root, "chargingTimeLimit", evse_get_charging_time_limit());
cJSON_AddNumberToObject(root, "defaultChargingTimeLimit", evse_get_default_charging_time_limit());
cJSON_AddNumberToObject(root, "underPowerLimit", evse_get_under_power_limit());
cJSON_AddNumberToObject(root, "defaultUnderPowerLimit", evse_get_default_under_power_limit());
cJSON_AddNumberToObject(root, "socketLockOperatingTime", socket_lock_get_operating_time());
cJSON_AddNumberToObject(root, "socketLockBreakTime", socket_lock_get_break_time());
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()));
char str[64];
cJSON_AddBoolToObject(root, "enabledocpp", ocpp_get_enabled());
ocpp_get_server(str);
cJSON_AddStringToObject(root, "serverocpp", str);
ocpp_get_rfid(str);
cJSON_AddStringToObject(root, "rfid", str);
return root;
}
esp_err_t json_set_evse_config(cJSON *root)
{
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "maxChargingCurrent")))
{
RETURN_ON_ERROR(evse_set_max_charging_current(cJSON_GetObjectItem(root, "maxChargingCurrent")->valuedouble));
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "chargingCurrent")))
{
RETURN_ON_ERROR(evse_set_charging_current(cJSON_GetObjectItem(root, "chargingCurrent")->valuedouble * 10));
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultChargingCurrent")))
{
RETURN_ON_ERROR(evse_set_default_charging_current(cJSON_GetObjectItem(root, "defaultChargingCurrent")->valuedouble * 10));
}
if (cJSON_IsBool(cJSON_GetObjectItem(root, "requireAuth")))
{
evse_set_require_auth(cJSON_IsTrue(cJSON_GetObjectItem(root, "requireAuth")));
}
if (cJSON_IsBool(cJSON_GetObjectItem(root, "socketOutlet")))
{
RETURN_ON_ERROR(evse_set_socket_outlet(cJSON_IsTrue(cJSON_GetObjectItem(root, "socketOutlet"))));
}
if (cJSON_IsBool(cJSON_GetObjectItem(root, "rcm")))
{
RETURN_ON_ERROR(evse_set_rcm(cJSON_IsTrue(cJSON_GetObjectItem(root, "rcm"))));
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "temperatureThreshold")))
{
RETURN_ON_ERROR(evse_set_temp_threshold(cJSON_GetObjectItem(root, "temperatureThreshold")->valuedouble));
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "consumptionLimit")))
{
evse_set_consumption_limit(cJSON_GetObjectItem(root, "consumptionLimit")->valuedouble);
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultConsumptionLimit")))
{
evse_set_default_consumption_limit(cJSON_GetObjectItem(root, "defaultConsumptionLimit")->valuedouble);
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "chargingTimeLimit")))
{
evse_set_charging_time_limit(cJSON_GetObjectItem(root, "chargingTimeLimit")->valuedouble);
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultChargingTimeLimit")))
{
evse_set_default_charging_time_limit(cJSON_GetObjectItem(root, "defaultChargingTimeLimit")->valuedouble);
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "underPowerLimit")))
{
evse_set_under_power_limit(cJSON_GetObjectItem(root, "underPowerLimit")->valuedouble);
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "defaultUnderPowerLimit")))
{
evse_set_default_under_power_limit(cJSON_GetObjectItem(root, "defaultUnderPowerLimit")->valuedouble);
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "socketLockOperatingTime")))
{
RETURN_ON_ERROR(socket_lock_set_operating_time(cJSON_GetObjectItem(root, "socketLockOperatingTime")->valuedouble));
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "socketLockBreakTime")))
{
RETURN_ON_ERROR(socket_lock_set_break_time(cJSON_GetObjectItem(root, "socketLockBreakTime")->valuedouble));
}
if (cJSON_IsBool(cJSON_GetObjectItem(root, "socketLockDetectionHigh")))
{
socket_lock_set_detection_high(cJSON_IsTrue(cJSON_GetObjectItem(root, "socketLockDetectionHigh")));
}
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "socketLockRetryCount")))
{
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)));
}
*/
if (cJSON_IsNumber(cJSON_GetObjectItem(root, "maxGridCurrent")))
{
RETURN_ON_ERROR(grid_set_max_current(cJSON_GetObjectItem(root, "maxGridCurrent")->valuedouble));
}
if (cJSON_IsBool(cJSON_GetObjectItem(root, "enabledocpp")))
{
ocpp_set_enabled(cJSON_IsTrue(cJSON_GetObjectItem(root, "enabledocpp")));
}
if (cJSON_IsString(cJSON_GetObjectItem(root, "serverocpp")))
{
ocpp_set_server(cJSON_GetStringValue(cJSON_GetObjectItem(root, "serverocpp")));
}
if (cJSON_IsString(cJSON_GetObjectItem(root, "rfid")))
{
ocpp_set_rfid(cJSON_GetStringValue(cJSON_GetObjectItem(root, "rfid")));
}
return ESP_OK;
}
cJSON *json_get_wifi_config(void)
{
cJSON *root = cJSON_CreateObject();
char str[32];
cJSON_AddBoolToObject(root, "enabled", wifi_get_enabled());
wifi_get_ssid(str);
cJSON_AddStringToObject(root, "ssid", str);
return root;
}
esp_err_t json_set_wifi_config(cJSON *root, bool timeout)
{
bool enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "enabled"));
char *ssid = cJSON_GetStringValue(cJSON_GetObjectItem(root, "ssid"));
char *password = cJSON_GetStringValue(cJSON_GetObjectItem(root, "password"));
if (timeout)
{
return timeout_wifi_set_config(enabled, ssid, password);
}
else
{
return wifi_set_config(enabled, ssid, password);
}
}
cJSON *json_get_wifi_scan(void)
{
cJSON *root = cJSON_CreateArray();
wifi_scan_ap_t scan_aps[WIFI_SCAN_SCAN_LIST_SIZE];
uint16_t number = wifi_scan(scan_aps);
for (int i = 0; i < number; i++)
{
cJSON *item = cJSON_CreateObject();
cJSON_AddStringToObject(item, "ssid", scan_aps[i].ssid);
cJSON_AddNumberToObject(item, "rssi", scan_aps[i].rssi);
cJSON_AddBoolToObject(item, "auth", scan_aps[i].auth);
cJSON_AddItemToArray(root, item);
}
return root;
}
cJSON *json_get_mqtt_config(void)
{
cJSON *root = cJSON_CreateObject();
char str[64];
cJSON_AddBoolToObject(root, "enabled", mqtt_get_enabled());
mqtt_get_server(str);
cJSON_AddStringToObject(root, "server", str);
mqtt_get_base_topic(str);
cJSON_AddStringToObject(root, "baseTopic", str);
mqtt_get_user(str);
cJSON_AddStringToObject(root, "user", str);
mqtt_get_password(str);
cJSON_AddStringToObject(root, "password", str);
cJSON_AddNumberToObject(root, "periodicity", mqtt_get_periodicity());
return root;
}
esp_err_t json_set_mqtt_config(cJSON *root)
{
bool enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "enabled"));
char *server = cJSON_GetStringValue(cJSON_GetObjectItem(root, "server"));
char *base_topic = cJSON_GetStringValue(cJSON_GetObjectItem(root, "baseTopic"));
char *user = cJSON_GetStringValue(cJSON_GetObjectItem(root, "user"));
char *password = cJSON_GetStringValue(cJSON_GetObjectItem(root, "password"));
uint16_t periodicity = cJSON_GetNumberValue(cJSON_GetObjectItem(root, "periodicity"));
return mqtt_set_config(enabled, server, base_topic, user, password, periodicity);
}
cJSON *json_get_modbus_config(void)
{
cJSON *root = cJSON_CreateObject();
//cJSON_AddBoolToObject(root, "tcpEnabled", modbus_tcp_is_enabled());
//cJSON_AddNumberToObject(root, "unitId", modbus_get_unit_id());
cJSON_AddBoolToObject(root, "tcpEnabled", false);
cJSON_AddNumberToObject(root, "unitId", 1);
return root;
}
esp_err_t json_set_modbus_config(cJSON *root)
{
//bool tcp_enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "tcpEnabled"));
//uint8_t unit_id = cJSON_GetObjectItem(root, "unitId")->valuedouble;
//modbus_tcp_set_enabled(tcp_enabled);
return 0; //modbus_set_unit_id(unit_id);
}
/*
cJSON* json_get_script_config(void)
{
cJSON* root = cJSON_CreateObject();
cJSON_AddBoolToObject(root, "enabled", script_is_enabled());
return root;
}
esp_err_t json_set_script_config(cJSON* root)
{
bool enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "enabled"));
script_set_enabled(enabled);
return ESP_OK;
}*/
cJSON *json_get_time_config(void)
{
cJSON *root = cJSON_CreateObject();
char str[64];
cJSON_AddBoolToObject(root, "ntpEnabled", date_time_is_ntp_enabled());
date_time_get_ntp_server(str);
cJSON_AddStringToObject(root, "ntpServer", str);
cJSON_AddBoolToObject(root, "ntpFromDhcp", date_time_is_ntp_from_dhcp());
date_time_get_timezone(str);
cJSON_AddStringToObject(root, "timezone", str);
return root;
}
esp_err_t json_set_time_config(cJSON *root)
{
char *ntp_server = cJSON_GetStringValue(cJSON_GetObjectItem(root, "ntpServer"));
bool ntp_enabled = cJSON_IsTrue(cJSON_GetObjectItem(root, "ntpEnabled"));
bool ntp_from_dhcp = cJSON_IsTrue(cJSON_GetObjectItem(root, "ntpFromDhcp"));
char *timezone = cJSON_GetStringValue(cJSON_GetObjectItem(root, "timezone"));
date_time_set_ntp_config(ntp_enabled, ntp_server, ntp_from_dhcp);
return date_time_set_timezone(timezone);
}
cJSON *json_get_state(void)
{
cJSON *root = cJSON_CreateObject();
cJSON_AddStringToObject(root, "state", evse_state_to_str(evse_get_state()));
cJSON_AddBoolToObject(root, "available", evse_is_available());
cJSON_AddBoolToObject(root, "enabled", evse_is_enabled());
cJSON_AddBoolToObject(root, "pendingAuth", evse_is_pending_auth());
cJSON_AddBoolToObject(root, "limitReached", evse_is_limit_reached());
uint32_t error = evse_error_get_bits();
if (error == 0)
{
cJSON_AddNullToObject(root, "errors");
}
else
{
cJSON *errors = cJSON_CreateArray();
if (error & EVSE_ERR_PILOT_FAULT_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("pilot_fault"));
}
if (error & EVSE_ERR_DIODE_SHORT_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("diode_short"));
}
if (error & EVSE_ERR_LOCK_FAULT_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("lock_fault"));
}
if (error & EVSE_ERR_UNLOCK_FAULT_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("unlock_fault"));
}
if (error & EVSE_ERR_RCM_TRIGGERED_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("rcm_triggered"));
}
if (error & EVSE_ERR_RCM_SELFTEST_FAULT_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("rcm_selftest_fault"));
}
if (error & EVSE_ERR_TEMPERATURE_HIGH_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("temperature_high"));
}
if (error & EVSE_ERR_TEMPERATURE_FAULT_BIT)
{
cJSON_AddItemToArray(errors, cJSON_CreateString("temperature_fault"));
}
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());
cJSON_AddNumberToObject(root, "power", energy_meter_get_power());
float values[3];
energy_meter_get_voltage(values);
cJSON_AddItemToObject(root, "voltage", cJSON_CreateFloatArray(values, 3));
energy_meter_get_current(values);
cJSON_AddItemToObject(root, "current", cJSON_CreateFloatArray(values, 3));
return root;
}
cJSON *json_get_info(void)
{
cJSON *root = cJSON_CreateObject();
cJSON_AddNumberToObject(root, "uptime", esp_timer_get_time() / 1000000);
const esp_app_desc_t *app_desc = esp_app_get_description();
cJSON_AddStringToObject(root, "appVersion", app_desc->version);
cJSON_AddStringToObject(root, "appDate", app_desc->date);
cJSON_AddStringToObject(root, "appTime", app_desc->time);
cJSON_AddStringToObject(root, "idfVersion", app_desc->idf_ver);
cJSON_AddStringToObject(root, "chip", CONFIG_IDF_TARGET);
esp_chip_info_t chip_info;
esp_chip_info(&chip_info);
cJSON_AddNumberToObject(root, "chipCores", chip_info.cores);
chip_info.revision = 301;
cJSON_AddNumberToObject(root, "chipRevision", chip_info.revision / 100);
multi_heap_info_t heap_info;
heap_caps_get_info(&heap_info, MALLOC_CAP_INTERNAL);
cJSON_AddNumberToObject(root, "heapSize", heap_info.total_allocated_bytes);
cJSON_AddNumberToObject(root, "maxHeapSize", heap_info.total_free_bytes + heap_info.total_allocated_bytes);
uint8_t mac[6];
char str[32];
esp_wifi_get_mac(ESP_IF_WIFI_STA, mac);
sprintf(str, MACSTR, MAC2STR(mac));
cJSON_AddStringToObject(root, "mac", str);
esp_netif_ip_info_t ip_info;
esp_netif_get_ip_info(esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"), &ip_info);
esp_ip4addr_ntoa(&ip_info.ip, str, sizeof(str));
cJSON_AddStringToObject(root, "ip", str);
esp_wifi_get_mac(ESP_IF_WIFI_AP, mac);
sprintf(str, MACSTR, MAC2STR(mac));
cJSON_AddStringToObject(root, "macAp", str);
esp_netif_get_ip_info(esp_netif_get_handle_from_ifkey("WIFI_AP_DEF"), &ip_info);
esp_ip4addr_ntoa(&ip_info.ip, str, sizeof(str));
cJSON_AddStringToObject(root, "ipAp", str);
cJSON_AddNumberToObject(root, "temperatureSensorCount", temp_sensor_get_count());
cJSON_AddNumberToObject(root, "temperatureLow", temp_sensor_get_low() / 100.0);
cJSON_AddNumberToObject(root, "temperatureHigh", temp_sensor_get_high() / 100.0);
return root;
}
static const char *serial_to_str(board_config_serial_t serial)
{
switch (serial)
{
case BOARD_CONFIG_SERIAL_UART:
return "uart";
case BOARD_CONFIG_SERIAL_RS485:
return "rs485";
default:
return "none";
}
}
cJSON *json_get_board_config(void)
{
cJSON *root = cJSON_CreateObject();
cJSON_AddStringToObject(root, "deviceName", board_config.device_name);
cJSON_AddBoolToObject(root, "socketLock", board_config.socket_lock);
cJSON_AddBoolToObject(root, "proximity", board_config.proximity);
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:
cJSON_AddStringToObject(root, "energyMeter", "cur");
break;
case BOARD_CONFIG_ENERGY_METER_CUR_VLT:
cJSON_AddStringToObject(root, "energyMeter", "cur_vlt");
break;
default:
cJSON_AddStringToObject(root, "energyMeter", "none");
}
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);
cJSON_AddStringToObject(root, "serial2", serial_to_str(board_config.serial_2));
cJSON_AddStringToObject(root, "serial2Name", board_config.serial_2_name);
#if SOC_UART_NUM > 2
cJSON_AddStringToObject(root, "serial3", serial_to_str(board_config.serial_3));
cJSON_AddStringToObject(root, "serial3Name", board_config.serial_3_name);
#else
cJSON_AddStringToObject(root, "serial3", serial_to_str(BOARD_CONFIG_SERIAL_NONE));
cJSON_AddStringToObject(root, "serial3Name", "");
#endif
cJSON *aux = cJSON_CreateArray();
if (board_config.aux_in_1)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_1_name));
}
if (board_config.aux_in_2)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_2_name));
}
if (board_config.aux_in_3)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_3_name));
}
if (board_config.aux_in_4)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_in_4_name));
}
cJSON_AddItemToObject(root, "auxIn", aux);
aux = cJSON_CreateArray();
if (board_config.aux_out_1)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_1_name));
}
if (board_config.aux_out_2)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_2_name));
}
if (board_config.aux_out_3)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_3_name));
}
if (board_config.aux_out_4)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_out_4_name));
}
cJSON_AddItemToObject(root, "auxOut", aux);
aux = cJSON_CreateArray();
if (board_config.aux_ain_1)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_ain_1_name));
}
if (board_config.aux_ain_2)
{
cJSON_AddItemToArray(aux, cJSON_CreateString(board_config.aux_ain_2_name));
}
cJSON_AddItemToObject(root, "auxAin", aux);
return root;
}