182 lines
7.8 KiB
C
182 lines
7.8 KiB
C
/*
|
|
* ESPRESSIF MIT License
|
|
*
|
|
* Copyright (c) 2018 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
|
|
*
|
|
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in which case,
|
|
* it is free of charge, to any person obtaining a copy of this software and associated
|
|
* documentation files (the "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
|
|
* to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all copies or
|
|
* substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include "string.h"
|
|
#include "esp_log.h"
|
|
#include "sense_modbus.h"
|
|
|
|
static const char *TAG = "sense_main";
|
|
|
|
// The number of parameters that intended to be used in the particular control process
|
|
#define SENSE_MAX_CIDS 6
|
|
|
|
// Timeout to update cid over Modbus if it is not updated by set/get request from mdf
|
|
#define MODBUS_VALUE_UPDATE_TIMEOUT_US (10000000)
|
|
#define MODBUS_GET_REQUEST_TIMEOUT (1000)
|
|
|
|
#define INIT_DELAY_TICS (100 / portTICK_RATE_MS)
|
|
#define TIMEOUT_UPDATE_CIDS_MS (1000)
|
|
#define TIMEOUT_UPDATE_CIDS_TICS (TIMEOUT_UPDATE_CIDS_MS / portTICK_RATE_MS)
|
|
|
|
#define SENSE_TRIGGER_TASK_STACK_SIZE (1024 * 4)
|
|
#define SENSE_TRIGGER_TASK_PRIO (6)
|
|
|
|
#define SENSE_MAIN_TAG "SENSE_MAIN"
|
|
|
|
#define SENS_MAIN_CHECK(a, ret_val, str, ...) \
|
|
if (!(a)) { \
|
|
ESP_LOGE(SENSE_MAIN_TAG, "%s(%u): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
|
return (ret_val); \
|
|
}
|
|
|
|
// Characteristic information table
|
|
static characteristic_descriptor_t* cid_table[SENSE_MAX_CIDS] = { 0 };
|
|
static uint16_t cid_counter = SENSE_MAX_CIDS;
|
|
|
|
// User operational task to trigger event when cid value exceeds limit
|
|
static void trigger_operation_task(void *arg)
|
|
{
|
|
float value;
|
|
uint64_t timeout = 0;
|
|
uint16_t temp_value = 0;
|
|
bool alarm_state = false;
|
|
bool relay_state = false;
|
|
characteristic_descriptor_t cid_data = { 0 };
|
|
|
|
while (1) {
|
|
alarm_state = false;
|
|
for (int cid = 0; cid < (CID_RELAY_P2); cid++)
|
|
{
|
|
// Get cid data
|
|
ESP_ERROR_CHECK_WITHOUT_ABORT(sense_modbus_get_cid_data(cid, &cid_data));
|
|
assert(cid_data.param_key != NULL);
|
|
assert(cid_data.instance_ptr != NULL);
|
|
// If value is not updated during 10 seconds then update it
|
|
timeout = esp_timer_get_time();
|
|
value = *(float*)cid_data.instance_ptr;
|
|
// Check limits to set alarm if exceeded limit
|
|
if (((value > cid_data.param_opts.max) ||
|
|
(value < cid_data.param_opts.min)) &&
|
|
(cid != CID_RELAY_P1)) {
|
|
alarm_state = true;
|
|
}
|
|
if (timeout > (cid_data.timestamp + MODBUS_VALUE_UPDATE_TIMEOUT_US)) {
|
|
// The value is not updated during timeout then update it
|
|
// The actual value is saved in the instance storage
|
|
value = 0;
|
|
esp_err_t error = sense_modbus_read_value(cid, (void*)&value);
|
|
if (error != ESP_OK) {
|
|
ESP_LOGE(SENSE_MAIN_TAG, "Update failed for cid: %u, %s(%s) = %d, %s",
|
|
(uint16_t)cid,
|
|
(char*)cid_data.param_key,
|
|
(char*)cid_data.param_units,
|
|
*(int*)cid_data.instance_ptr,
|
|
(char*)esp_err_to_name(error));
|
|
} else {
|
|
// Update state of alarm
|
|
if (cid == CID_RELAY_P1) {
|
|
// Get actual relay state
|
|
relay_state = (*(uint16_t*)(cid_data.instance_ptr)
|
|
& (uint16_t)(cid_data.param_opts.opt1));
|
|
const char* relay_state_str = relay_state ? "ON" : "OFF";
|
|
ESP_LOGI(SENSE_MAIN_TAG, "cid: %u, (%s) = %s", (uint16_t)cid,
|
|
(char*)cid_data.param_key,
|
|
(const char*)relay_state_str);
|
|
} else {
|
|
// Update read value
|
|
ESP_LOGI(SENSE_MAIN_TAG, "cid: %u, %s(%s) = %.2f", (uint16_t)cid,
|
|
(char*)cid_data.param_key,
|
|
(char*)cid_data.param_units,
|
|
(float)value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Check all characteristics if they exceed limits and set alarm accordingly
|
|
if (!alarm_state) {
|
|
if (relay_state == true) {
|
|
ESP_LOGI(SENSE_MAIN_TAG, "The values within the limit, then release relay.");
|
|
temp_value = 0;
|
|
// Release the relay in IO slave device
|
|
// Do not check an error in this example (IO slave may be not configured)
|
|
(void)sense_modbus_send_value(CID_RELAY_P1, &temp_value);
|
|
relay_state = false;
|
|
}
|
|
} else {
|
|
if (!relay_state) {
|
|
ESP_LOGI(SENSE_MAIN_TAG, "The value exceeds limit, then set relay.");
|
|
temp_value = 0x00FF;
|
|
(void)sense_modbus_send_value(CID_RELAY_P1, &temp_value); // Set the relay
|
|
relay_state = true;
|
|
}
|
|
}
|
|
|
|
vTaskDelay(TIMEOUT_UPDATE_CIDS_TICS);
|
|
}
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
static void sense_device_init(void)
|
|
{
|
|
// Initialize and start Modbus controller
|
|
sense_modbus_init();
|
|
}
|
|
|
|
void app_main(void)
|
|
{
|
|
esp_err_t result = ESP_OK;
|
|
|
|
// Initialization of device peripheral and objects
|
|
sense_device_init();
|
|
|
|
// Get all supported modbus characteristics from modbus controller
|
|
result = sense_modbus_get_characteristics(&cid_table[0], &cid_counter);
|
|
assert((result == ESP_OK) && (cid_counter >= 1));
|
|
ESP_LOGI(TAG, "Found (%u) characteristics in the table.", cid_counter);
|
|
characteristic_descriptor_t* sid_descr_ptr = { 0 };
|
|
float value = 0;
|
|
esp_err_t err = ESP_OK;
|
|
int cid_registered = 0;
|
|
// Read all found characteristics
|
|
for (uint16_t cid = 0; cid < cid_counter; cid++) {
|
|
sid_descr_ptr = cid_table[cid];
|
|
// Initially read of Modbus values and check status
|
|
err = sense_modbus_read_value(cid, (void*)&value);
|
|
if (err == ESP_OK) {
|
|
ESP_LOGI(TAG, "Characteristic (%s) data = 0x%.4x read successful.",
|
|
(char*)sid_descr_ptr->param_key, (unsigned int)value);
|
|
cid_registered++;
|
|
} else {
|
|
ESP_LOGE(TAG, "Characteristic (%s) read value fail, err = %d (%s).",
|
|
(char*)sid_descr_ptr->param_key,
|
|
(int)err,
|
|
(char*)esp_err_to_name(err));
|
|
}
|
|
}
|
|
|
|
// Starts operation task to check values and trigger an event
|
|
xTaskCreate(trigger_operation_task, "trigger_operation_task",
|
|
SENSE_TRIGGER_TASK_STACK_SIZE, NULL, SENSE_TRIGGER_TASK_PRIO, NULL);
|
|
}
|