FabInfra-Mirror/fabhardware.fabmeter
1
0
Fork 0
mirror of https://gitlab.com/fabinfra/fabhardware/fabmeter.git synced 2025-03-12 22:51:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
fabhardware.fabmeter/main/fabmeter.c
Kai Jan Kriegel 0d603b7d26
Initial commit
2023-07-24 02:02:48 +02:00

315 lines
22 KiB
C
Raw Blame History

/*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#include <esp_err.h>
#include <esp_wifi.h>
#include <esp_event.h>
#include <esp_log.h>
#include <nvs_flash.h>
#include <esp_crt_bundle.h>
#include <esp_insights.h>
#include <mqtt_client.h>
#include "modbus_params.h" // for modbus parameters structures
#include "mbcontroller.h"
#include "sdkconfig.h"
#include "modbus_utils.h"
#include "mqtt_event_handler.h"
#include "net_event_handler.h"
#include "initializers.h"
#define ESP_INSIGHTS_AUTH_KEY "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoiYzI3N2M3NzUtZDNjNy00NjEzLWIwMzctYjYxZGVjNmUyMGRmIiwiaXNzIjoiZTMyMmI1OWMtNjNjYy00ZTQwLThlYTItNGU3NzY2NTQ1Y2NhIiwic3ViIjoiYjExZWMyZWEtZGE5Ni00ZTQyLWIzODktOWU2MGNlM2U3Y2ZkIiwiZXhwIjoyMDA1MDA0ODk0LCJpYXQiOjE2ODk2NDQ4OTR9.FOPLo6qvkVI5k0M0j8YWonc7jRrTc6wG1p0001awcC6bWEOIxoheY69ZXSbn94vFiCtLyWAJafce3QrLJWgW0THDxGZaUNrjijqLXdKie7qEOVinjsdwILomIMa_NpSVLwZimAkd6B_uw1hk5RqooW2JzJeLYLX5i7oUgSAwZgvjN_cfCS2emrSKpZXD-CaDlNMGjt97VXzj4UFuDsNCWLaW0gEr5RcMMnYFwSxkLgv1NOWGQKfm1mZCRA_swCyxvjX4UrjlWSQZemqiqBMgnW7sBAyG5-UFGu1Fc-MfBfoB9aGblPE7LDwMeT1jgJUaJ9puhDFMY-v4Ilw8jUttzA"
// The number of parameters that intended to be used in the particular control process
#define MASTER_MAX_CIDS num_device_parameters
// Number of reading of parameters from slave
#define MASTER_MAX_RETRY 300
// Timeout to update cid over Modbus
#define UPDATE_CIDS_TIMEOUT_MS (5000)
#define UPDATE_CIDS_TIMEOUT_TICS (UPDATE_CIDS_TIMEOUT_MS / portTICK_PERIOD_MS)
// Timeout between polls
#define POLL_TIMEOUT_MS (1)
#define POLL_TIMEOUT_TICS (POLL_TIMEOUT_MS / portTICK_PERIOD_MS)
static const char *TAG = "FABMETER";
// Enumeration of modbus device addresses accessed by master device
enum {
MB_DEVICE_ADDR1 = 1 // Only one slave device used for the test (add other slave addresses here)
};
// Example Data (Object) Dictionary for Modbus parameters:
// The CID field in the table must be unique.
// Modbus Slave Addr field defines slave address of the device with correspond parameter.
// Modbus Reg Type - Type of Modbus register area (Holding register, Input Register and such).
// Reg Start field defines the start Modbus register number and Reg Size defines the number of registers for the characteristic accordingly.
// The Instance Offset defines offset in the appropriate parameter structure that will be used as instance to save parameter value.
// Data Type, Data Size specify type of the characteristic and its data size.
// Parameter Options field specifies the options that can be used to process parameter value (limits or masks).
// Access Mode - can be used to implement custom options for processing of characteristic (Read/Write restrictions, factory mode values and etc).
const mb_parameter_descriptor_t device_parameters[] = {
// { CID, Param Name, Units, Modbus Slave Addr, Modbus Reg Type, Reg Start, Reg Size, Instance Offset, Data Type, Data Size, Parameter Options, Access Mode}
{ CID_INP_U_L1N, STR("Phase 1 line to neutral"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0000, 2,
INPUT_OFFSET(voltage_L1N), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_L2N, STR("Phase 2 line to neutral"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0002, 2,
INPUT_OFFSET(voltage_L2N), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_L3N, STR("Phase 3 line to neutral"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0004, 2,
INPUT_OFFSET(voltage_L3N), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ},
{ CID_INP_I_L1, STR("Phase 1 current"), STR("A"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0006, 2,
INPUT_OFFSET(current_L1), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_I_L2, STR("Phase 2 current"), STR("A"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0008, 2,
INPUT_OFFSET(current_L2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_I_L3, STR("Phase 3 current"), STR("A"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x000A, 2,
INPUT_OFFSET(current_L3), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_P_L1, STR("Phase 1 active power"), STR("W"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x000C, 2,
INPUT_OFFSET(active_power_L1), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_P_L2, STR("Phase 2 active power"), STR("W"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x000E, 2,
INPUT_OFFSET(active_power_L2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_P_L3, STR("Phase 3 active power"), STR("W"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0010, 2,
INPUT_OFFSET(active_power_L3), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_S_L1, STR("Phase 1 apparent power"), STR("VA"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0012, 2,
INPUT_OFFSET(apparent_power_L1), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_S_L2, STR("Phase 2 apparent power"), STR("VA"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0014, 2,
INPUT_OFFSET(apparent_power_L2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_S_L3, STR("Phase 3 apparent power"), STR("VA"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0016, 2,
INPUT_OFFSET(apparent_power_L3), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_Q_L1, STR("Phase 1 reactive power"), STR("VAR"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0018,
2, INPUT_OFFSET(reactive_power_L1), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_Q_L2, STR("Phase 2 reactive power"), STR("VAR"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x001A,
2, INPUT_OFFSET(reactive_power_L2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_Q_L3, STR("Phase 3 reactive power"), STR("VAR"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x001C,
2, INPUT_OFFSET(reactive_power_L3), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_PF_L1, STR("Phase 1 power factor"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x001E, 2,
INPUT_OFFSET(power_factor_L1), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_PF_L2, STR("Phase 2 power factor"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0020, 2,
INPUT_OFFSET(power_factor_L2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_PF_L3, STR("Phase 3 power factor"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0022, 2,
INPUT_OFFSET(power_factor_L3), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_LN_AVG, STR("Average line-to-neutral voltage"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x002A,
2, INPUT_OFFSET(voltage_avg_LN), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_I_L_AVG, STR("Average line current"), STR("A"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x002E,
2, INPUT_OFFSET(current_avg), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_I_SUM, STR("Sum of line currents"), STR("A"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0030,
2, INPUT_OFFSET(current_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_P_SUM, STR("Total system power"), STR("W"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0034,
2, INPUT_OFFSET(active_power_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_S_SUM, STR("Total system apparent power"), STR("VA"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0038,
2, INPUT_OFFSET(apparent_power_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_Q_SUM, STR("Total system reactive power"), STR("VAR"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x003C,
2, INPUT_OFFSET(reactive_power_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_PF_SUM, STR("Total system power factor"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x003E,
2, INPUT_OFFSET(power_factor_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_FREQ, STR("Line frequency"), STR("Hz"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0046, 2,
INPUT_OFFSET(frequency), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_IMP, STR("Imported energy"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0048, 2,
INPUT_OFFSET(active_energy_import), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_EXP, STR("Exported energy"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x004A, 2,
INPUT_OFFSET(active_energy_export), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_L1L2, STR("Phase 1 to phase 2 voltage"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x004C,
2, INPUT_OFFSET(voltage_L1L2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_L2L3, STR("Phase 2 to phase 3 voltage"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x004E,
2, INPUT_OFFSET(voltage_L2L3), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_L3L1, STR("Phase 3 to phase 1 voltage"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0050,
2, INPUT_OFFSET(voltage_L3L1), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_U_LL_AVG, STR("Average line-to-line voltage"), STR("V"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0052,
2, INPUT_OFFSET(voltage_avg_LL), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_I_N, STR("Neutral current"), STR("A"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0054,
2, INPUT_OFFSET(current_N), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_SUM, STR("Total Energy"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0156,
2, INPUT_OFFSET(active_energy_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_Eq_SUM, STR("Total reactive Energy"), STR("kVARh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0158,
2, INPUT_OFFSET(reactive_energy_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_RESET_SUM, STR("resettable total energy"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0180,
2, INPUT_OFFSET(active_energy_resettable_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_Eq_RESET_SUM, STR("resettable total reactive energy"), STR("kVARh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0182,
2, INPUT_OFFSET(reactive_energy_resettable_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_RESET_IMP, STR("resettable total imported energy"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0184,
2, INPUT_OFFSET(active_energy_import_resettable), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_RESET_EXP, STR("resettable total exported energy"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0186,
2, INPUT_OFFSET(active_energy_export_resettable), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_E_NET, STR("Net kWh (Import - Export)"), STR("kWh"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x018C,
2, INPUT_OFFSET(active_energy_net), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_P_IMP_SUM, STR("Total imported power"), STR("W"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0500,
2, INPUT_OFFSET(active_power_import_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_INP_P_EXP_SUM, STR("Total exported power"), STR("W"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0x0502,
2, INPUT_OFFSET(active_power_export_sum), PARAM_TYPE_FLOAT, 4, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_HLD_SYS_TYPE, STR("System Type"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x000A,
2, HOLD_OFFSET(sys_type), PARAM_TYPE_FLOAT, 4, OPTS( 1, 3, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_PULSE_WIDTH, STR("Pulse Width"), STR("ms"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x000C,
2, HOLD_OFFSET(pulse_width), PARAM_TYPE_FLOAT, 4, OPTS( 60, 200, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_KPPA, STR("Key Parameter Programming Authorization (KPPA)"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x000E,
2, HOLD_OFFSET(kppa), PARAM_TYPE_FLOAT, 4, OPTS( 0, 1, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_PARITY_AND_STOP, STR("Parity and stop bit"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x0012,
2, HOLD_OFFSET(kppa), PARAM_TYPE_FLOAT, 4, OPTS( 0, 3, 0 ), PAR_PERMS_READ_WRITE},
{ CID_HLD_MB_ADDR, STR("Modbus address"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x0014,
2, HOLD_OFFSET(modbus_addr), PARAM_TYPE_FLOAT, 4, OPTS( 1, 247, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_PULSE_CONST, STR("Pulse Constant"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x0016,
2, HOLD_OFFSET(pulse_const), PARAM_TYPE_FLOAT, 4, OPTS( 0, 3, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_PASSWD, STR("Password"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x0018,
2, HOLD_OFFSET(password), PARAM_TYPE_FLOAT, 4, OPTS( 0, 9999, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_BAUDRATE, STR("Baudrate"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x001C,
2, HOLD_OFFSET(baudrate), PARAM_TYPE_FLOAT, 4, OPTS( 0, 5, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_AUTO_SCROLL_TIME, STR("Auto Scroll Time"), STR("s"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x003A,
2, HOLD_OFFSET(auto_scroll_time), PARAM_TYPE_FLOAT, 4, OPTS( 0, 60, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_BACKLIGHT_TIME, STR("Backlight Time"), STR("min"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x003C,
2, HOLD_OFFSET(backlight_time), PARAM_TYPE_FLOAT, 4, OPTS( 0, 121, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_PULSE_1_E_TYPE, STR("Pulse 1 Energy Type"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0x0056,
2, HOLD_OFFSET(pulse_1_energy_type), PARAM_TYPE_FLOAT, 4, OPTS( 0, 4, 0 ), PAR_PERMS_READ_WRITE },
{ CID_HLD_RST_HIST, STR("Reset historical data"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0xF010,
1, HOLD_OFFSET(reset_history), PARAM_TYPE_U16, 2, OPTS( 0, 1, 0 ), PAR_PERMS_WRITE },
{ CID_HLD_SERIAL, STR("Serial number"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0xFC00,
2, HOLD_OFFSET(serial_number), PARAM_TYPE_U16, 2, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_HLD_METER_TYPE, STR("Meter type"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0xFC02,
1, HOLD_OFFSET(meter_type), PARAM_TYPE_U16, 2, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
{ CID_HLD_METER_FIRMWARE, STR("Firmware version"), STR(""), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0xFC84,
1, HOLD_OFFSET(fw_version), PARAM_TYPE_U16, 2, OPTS( 0, 0, 0 ), PAR_PERMS_READ },
};
// Calculate number of parameters in the table
const uint16_t num_device_parameters = (sizeof(device_parameters)/sizeof(device_parameters[0]));
// User operation function to read slave values and check alarm
static void modbus_poller(void *arg)
{
esp_err_t err = ESP_OK;
uint32_t value = 0;
uint8_t type = 0;
const mb_parameter_descriptor_t* param_descriptor = NULL;
char topic[512];
ESP_LOGI(TAG, "Start modbus poller");
for(;;) {
// Read all found characteristics from slave(s)
for (uint16_t cid = 0; (err != ESP_ERR_NOT_FOUND) && cid < MASTER_MAX_CIDS; cid++)
{
// Get data from parameters description table
// and use this information to fill the characteristics description table
// and having all required fields in just one table
err = mbc_master_get_cid_info(cid, &param_descriptor);
if ((err != ESP_ERR_NOT_FOUND) && (param_descriptor != NULL)) {
void* temp_data_ptr = master_get_param_data(param_descriptor);
assert(temp_data_ptr);
type = param_descriptor->param_type;
extern esp_mqtt_client_handle_t mqtt_client;
err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)&value, &type);
if (err == ESP_OK) {
*(uint32_t*)temp_data_ptr = __beswap_32(value);
char payload[32];
switch (param_descriptor->param_type)
{
case PARAM_TYPE_FLOAT:
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = %f (0x%"PRIu32") read successful.",
param_descriptor->cid,
(char*)param_descriptor->param_key,
(char*)param_descriptor->param_units,
*(float*)temp_data_ptr,
*(uint32_t*)temp_data_ptr);
snprintf(topic, 512, "fabmeter/%05d/%s", CONFIG_FABMETER_ID, (char*)param_descriptor->param_key);
snprintf(payload, 32, "%f", *(float*)temp_data_ptr);
esp_mqtt_client_publish(mqtt_client, topic, payload, 0, 0, 0);
break;
case PARAM_TYPE_U8:
ESP_LOGI(TAG, "Characteristic #%d %s value = 0x%"PRIu8" read successful.",
param_descriptor->cid,
(char*)param_descriptor->param_key,
*(uint8_t*)temp_data_ptr);
snprintf(topic, 512, "fabmeter/%05d/%s", CONFIG_FABMETER_ID, (char*)param_descriptor->param_key);
snprintf(payload, 32, "0x%"PRIu8"", *(uint8_t*)temp_data_ptr);
esp_mqtt_client_publish(mqtt_client, topic, payload, 0, 0, 0);
break;
case PARAM_TYPE_U16:
ESP_LOGI(TAG, "Characteristic #%d %s value = 0x%"PRIu16" read successful.",
param_descriptor->cid,
(char*)param_descriptor->param_key,
*(uint16_t*)temp_data_ptr);
snprintf(topic, 512, "fabmeter/%05d/%s", CONFIG_FABMETER_ID, (char*)param_descriptor->param_key);
snprintf(payload, 32, "0x%"PRIu16"", *(uint16_t*)temp_data_ptr);
esp_mqtt_client_publish(mqtt_client, topic, payload, 0, 0, 0);
break;
case PARAM_TYPE_U32:
ESP_LOGI(TAG, "Characteristic #%d %s value = 0x%"PRIu32" read successful.",
param_descriptor->cid,
(char*)param_descriptor->param_key,
*(uint32_t*)temp_data_ptr);
snprintf(topic, 512, "fabmeter/%05d/%s", CONFIG_FABMETER_ID, (char*)param_descriptor->param_key);
snprintf(payload, 32, "0x%"PRIu32"", *(uint32_t*)temp_data_ptr);
esp_mqtt_client_publish(mqtt_client, topic, payload, 0, 0, 0);
break;
case PARAM_TYPE_ASCII:
ESP_LOGI(TAG, "Characteristic #%d %s value = %s read successful.",
param_descriptor->cid,
(char*)param_descriptor->param_key,
(char*)temp_data_ptr);
snprintf(topic, 512, "fabmeter/%05d/%s", CONFIG_FABMETER_ID, (char*)param_descriptor->param_key);
snprintf(payload, 32, "%s", (char*)temp_data_ptr);
esp_mqtt_client_publish(mqtt_client, topic, payload, 0, 0, 0);
break;
default:
break;
}
} else {
ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%d (%s).",
param_descriptor->cid,
(char*)param_descriptor->param_key,
(int)err,
(char*)esp_err_to_name(err));
}
vTaskDelay(POLL_TIMEOUT_TICS); // delay between cids
}
}
vTaskDelay(UPDATE_CIDS_TIMEOUT_TICS); // delay between updates
}
}
void app_main(void)
{
extern led_strip_handle_t debug_led;
esp_insights_config_t config = {
.log_type = ESP_DIAG_LOG_TYPE_ERROR,
.auth_key = ESP_INSIGHTS_AUTH_KEY,
};
// Initialization of device peripheral and objects
init_led_strip();
ESP_ERROR_CHECK(led_strip_set_pixel(debug_led, 0, 0xFF, 0, 0));
ESP_ERROR_CHECK(led_strip_refresh(debug_led));
init_eventloop();
init_nvs();
init_wifi();
esp_insights_init(&config);
init_mqtt();
ESP_ERROR_CHECK(init_modbus(&device_parameters[0], num_device_parameters));
vTaskDelay(10);
modbus_poller(NULL);
}
Reference in New Issue View Git Blame Copy Permalink