/* * SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ #include #include #include #include #include #include #include #include #include #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, ¶m_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); }