Adicionar primeiro
This commit is contained in:
@@ -0,0 +1,20 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
// Stack callback functions prototypes
|
||||
|
||||
#ifndef _ESP_MODBUS_CALLBACKS_H_
|
||||
#define _ESP_MODBUS_CALLBACKS_H_
|
||||
|
||||
#include "mb.h"
|
||||
#include "mb_m.h"
|
||||
|
||||
typedef eMBErrorCode (*reg_input_cb)(UCHAR*, USHORT, USHORT);
|
||||
typedef eMBErrorCode (*reg_holding_cb)(UCHAR*, USHORT, USHORT, eMBRegisterMode);
|
||||
typedef eMBErrorCode (*reg_coils_cb)(UCHAR*, USHORT, USHORT, eMBRegisterMode);
|
||||
typedef eMBErrorCode (*reg_discrete_cb)(UCHAR*, USHORT, USHORT);
|
||||
|
||||
#endif /* _ESP_MODBUS_CALLBACKS_H_ */
|
||||
@@ -0,0 +1,532 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "esp_err.h" // for esp_err_t
|
||||
#include "mbc_master.h" // for master interface define
|
||||
#include "esp_modbus_master.h" // for public interface defines
|
||||
#include "esp_modbus_callbacks.h" // for callback functions
|
||||
#include "sdkconfig.h"
|
||||
|
||||
static const char TAG[] __attribute__((unused)) = "MB_CONTROLLER_MASTER";
|
||||
|
||||
// This file implements public API for Modbus master controller.
|
||||
// These functions are wrappers for interface functions of the controller
|
||||
static mb_master_interface_t* master_interface_ptr = NULL;
|
||||
|
||||
void mbc_master_init_iface(void* handler)
|
||||
{
|
||||
master_interface_ptr = (mb_master_interface_t*) handler;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modbus controller destroy function
|
||||
*/
|
||||
esp_err_t mbc_master_destroy(void)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->destroy != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->destroy();
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master destroy failure, error=(0x%x).",
|
||||
(int)error);
|
||||
return error;
|
||||
}
|
||||
|
||||
esp_err_t mbc_master_get_cid_info(uint16_t cid, const mb_parameter_descriptor_t** param_info)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->get_cid_info != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->get_cid_info(cid, param_info);
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master get cid info failure, error=(0x%x).",
|
||||
(int)error);
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parameter data for corresponding characteristic
|
||||
*/
|
||||
esp_err_t mbc_master_get_parameter(uint16_t cid, char* name, uint8_t* value, uint8_t* type)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->get_parameter != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->get_parameter(cid, name, value, type);
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master get parameter failure, error=(0x%x) (%s).",
|
||||
(int)error, esp_err_to_name(error));
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send custom Modbus request defined as mb_param_request_t structure
|
||||
*/
|
||||
esp_err_t mbc_master_send_request(mb_param_request_t* request, void* data_ptr)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->send_request != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->send_request(request, data_ptr);
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master send request failure error=(0x%x) (%s).",
|
||||
(int)error, esp_err_to_name(error));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Modbus parameter description table
|
||||
*/
|
||||
esp_err_t mbc_master_set_descriptor(const mb_parameter_descriptor_t* descriptor,
|
||||
const uint16_t num_elements)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->set_descriptor != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->set_descriptor(descriptor, num_elements);
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master set descriptor failure, error=(0x%x) (%s).",
|
||||
(int)error, esp_err_to_name(error));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set parameter value for characteristic selected by name and cid
|
||||
*/
|
||||
esp_err_t mbc_master_set_parameter(uint16_t cid, char* name, uint8_t* value, uint8_t* type)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->set_parameter != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->set_parameter(cid, name, value, type);
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master set parameter failure, error=(0x%x) (%s).",
|
||||
(int)error, esp_err_to_name(error));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Setup Modbus controller parameters
|
||||
*/
|
||||
esp_err_t mbc_master_setup(void* comm_info)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->setup != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->setup(comm_info);
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master setup failure, error=(0x%x) (%s).",
|
||||
(int)error, esp_err_to_name(error));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modbus controller stack start function
|
||||
*/
|
||||
esp_err_t mbc_master_start(void)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->start != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->start();
|
||||
MB_MASTER_CHECK((error == ESP_OK),
|
||||
error,
|
||||
"Master start failure, error=(0x%x) (%s).",
|
||||
(int)error, esp_err_to_name(error));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBMasterRegDiscreteCB(UCHAR * pucRegBuffer, USHORT usAddress,
|
||||
USHORT usNDiscrete)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->master_reg_cb_discrete != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->master_reg_cb_discrete(pucRegBuffer, usAddress, usNDiscrete);
|
||||
return error;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBMasterRegCoilsCB(UCHAR* pucRegBuffer, USHORT usAddress,
|
||||
USHORT usNCoils, eMBRegisterMode eMode)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->master_reg_cb_coils != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->master_reg_cb_coils(pucRegBuffer, usAddress,
|
||||
usNCoils, eMode);
|
||||
return error;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBMasterRegHoldingCB(UCHAR * pucRegBuffer, USHORT usAddress,
|
||||
USHORT usNRegs, eMBRegisterMode eMode)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->master_reg_cb_holding != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->master_reg_cb_holding(pucRegBuffer, usAddress,
|
||||
usNRegs, eMode);
|
||||
return error;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBMasterRegInputCB(UCHAR * pucRegBuffer, USHORT usAddress,
|
||||
USHORT usNRegs)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_MASTER_CHECK((master_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
MB_MASTER_CHECK((master_interface_ptr->master_reg_cb_input != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master interface is not correctly initialized.");
|
||||
error = master_interface_ptr->master_reg_cb_input(pucRegBuffer, usAddress, usNRegs);
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to get current transaction info
|
||||
*/
|
||||
esp_err_t mbc_master_get_transaction_info(mb_trans_info_t *ptinfo)
|
||||
{
|
||||
MB_MASTER_CHECK((ptinfo),
|
||||
ESP_ERR_INVALID_ARG,
|
||||
"Wrong argument.");
|
||||
MB_MASTER_CHECK(xMBMasterGetLastTransactionInfo(&ptinfo->trans_id, &ptinfo->dest_addr,
|
||||
&ptinfo->func_code, &ptinfo->exception,
|
||||
&ptinfo->err_type),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Master can not get transaction info.");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// Helper function to set parameter buffer according to its type
|
||||
esp_err_t mbc_master_set_param_data(void* dest, void* src, mb_descr_type_t param_type, size_t param_size)
|
||||
{
|
||||
esp_err_t err = ESP_OK;
|
||||
MB_RETURN_ON_FALSE((src), ESP_ERR_INVALID_STATE, TAG,"incorrect data pointer.");
|
||||
MB_RETURN_ON_FALSE((dest), ESP_ERR_INVALID_STATE, TAG,"incorrect data pointer.");
|
||||
void *pdest = dest;
|
||||
void *psrc = src;
|
||||
|
||||
// Transfer parameter data into value of characteristic
|
||||
switch(param_type)
|
||||
{
|
||||
case PARAM_TYPE_U8:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8) {
|
||||
*((uint8_t*)pdest) = *((uint8_t*)psrc);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U16:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U16) {
|
||||
*((uint16_t*)pdest) = *((uint16_t*)psrc);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U32:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) {
|
||||
*((uint32_t*)pdest) = *((uint32_t*)psrc);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_FLOAT:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) {
|
||||
*((float*)pdest) = *(float*)psrc;
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_ASCII:
|
||||
case PARAM_TYPE_BIN:
|
||||
memcpy((void*)dest, (void*)src, (size_t)param_size);
|
||||
break;
|
||||
|
||||
#if CONFIG_FMB_EXT_TYPE_SUPPORT
|
||||
|
||||
case PARAM_TYPE_I8_A:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) {
|
||||
mb_set_int8_a((val_16_arr *)pdest, (*(int8_t*)psrc));
|
||||
ESP_LOGV(TAG, "Convert uint8 B[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I8_B:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) {
|
||||
mb_set_int8_b((val_16_arr *)pdest, (int8_t)((*(uint16_t*)psrc) >> 8));
|
||||
ESP_LOGV(TAG, "Convert int8 A[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U8_A:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) {
|
||||
mb_set_uint8_a((val_16_arr *)pdest, (*(uint8_t*)psrc));
|
||||
ESP_LOGV(TAG, "Convert uint8 A[%d] 0x%02" PRIx16 " = %02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U8_B:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) {
|
||||
uint8_t data = (uint8_t)((*(uint16_t*)psrc) >> 8);
|
||||
mb_set_uint8_b((val_16_arr *)pdest, data);
|
||||
ESP_LOGV(TAG, "Convert uint8 B[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I16_AB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I16) {
|
||||
mb_set_int16_ab((val_16_arr *)pdest, *(int16_t*)psrc);
|
||||
ESP_LOGV(TAG, "Convert int16 AB[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I16_BA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I16) {
|
||||
mb_set_int16_ba((val_16_arr *)pdest, *(int16_t*)psrc);
|
||||
ESP_LOGV(TAG, "Convert int16 BA[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U16_AB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U16) {
|
||||
mb_set_uint16_ab((val_16_arr *)pdest, *(uint16_t*)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint16 AB[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U16_BA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U16) {
|
||||
mb_set_uint16_ba((val_16_arr *)pdest, *(uint16_t*)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint16 BA[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I32_ABCD:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) {
|
||||
mb_set_int32_abcd((val_32_arr *)pdest, *(int32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int32 ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U32_ABCD:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) {
|
||||
mb_set_uint32_abcd((val_32_arr *)pdest, *(uint32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint32 ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_FLOAT_ABCD:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) {
|
||||
mb_set_float_abcd((val_32_arr *)pdest, *(float *)psrc);
|
||||
ESP_LOGV(TAG, "Convert float ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I32_CDAB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) {
|
||||
mb_set_int32_cdab((val_32_arr *)pdest, *(int32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int32 CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U32_CDAB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) {
|
||||
mb_set_uint32_cdab((val_32_arr *)pdest, *(uint32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint32 CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_FLOAT_CDAB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) {
|
||||
mb_set_float_cdab((val_32_arr *)pdest, *(float *)psrc);
|
||||
ESP_LOGV(TAG, "Convert float CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I32_BADC:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) {
|
||||
mb_set_int32_badc((val_32_arr *)pdest, *(int32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int32 BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U32_BADC:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) {
|
||||
mb_set_uint32_badc((val_32_arr *)pdest, *(uint32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint32 BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_FLOAT_BADC:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) {
|
||||
mb_set_float_badc((val_32_arr *)pdest, *(float *)psrc);
|
||||
ESP_LOGV(TAG, "Convert float BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I32_DCBA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) {
|
||||
mb_set_int32_dcba((val_32_arr *)pdest, *(int32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int32 DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U32_DCBA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) {
|
||||
mb_set_uint32_dcba((val_32_arr *)pdest, *(uint32_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint32 DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_FLOAT_DCBA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) {
|
||||
mb_set_float_dcba((val_32_arr *)pdest, *(float *)psrc);
|
||||
ESP_LOGV(TAG, "Convert float DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I64_ABCDEFGH:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) {
|
||||
mb_set_int64_abcdefgh((val_64_arr *)pdest, *(int64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int64 ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U64_ABCDEFGH:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) {
|
||||
mb_set_uint64_abcdefgh((val_64_arr *)pdest, *(uint64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert double ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_DOUBLE_ABCDEFGH:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) {
|
||||
mb_set_double_abcdefgh((val_64_arr *)pdest, *(double *)psrc);
|
||||
ESP_LOGV(TAG, "Convert double ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I64_HGFEDCBA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) {
|
||||
mb_set_int64_hgfedcba((val_64_arr *)pdest, *(int64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int64 HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U64_HGFEDCBA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) {
|
||||
mb_set_uint64_hgfedcba((val_64_arr *)pdest, *(uint64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert double HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_DOUBLE_HGFEDCBA:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) {
|
||||
mb_set_double_hgfedcba((val_64_arr *)pdest, *(double *)psrc);
|
||||
ESP_LOGV(TAG, "Convert double HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I64_GHEFCDAB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) {
|
||||
mb_set_int64_ghefcdab((val_64_arr *)pdest, *(int64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int64 GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U64_GHEFCDAB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) {
|
||||
mb_set_uint64_ghefcdab((val_64_arr *)pdest, *(uint64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint64 GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_DOUBLE_GHEFCDAB:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) {
|
||||
mb_set_double_ghefcdab((val_64_arr *)pdest, *(double *)psrc);
|
||||
ESP_LOGV(TAG, "Convert double GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_I64_BADCFEHG:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) {
|
||||
mb_set_int64_badcfehg((val_64_arr *)pdest, *(int64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert int64 BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_U64_BADCFEHG:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) {
|
||||
mb_set_uint64_badcfehg((val_64_arr *)pdest, *(uint64_t *)psrc);
|
||||
ESP_LOGV(TAG, "Convert uint64 BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
case PARAM_TYPE_DOUBLE_BADCFEHG:
|
||||
for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) {
|
||||
mb_set_double_badcfehg((val_64_arr *)pdest, *(double *)psrc);
|
||||
ESP_LOGV(TAG, "Convert double BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest);
|
||||
}
|
||||
break;
|
||||
|
||||
#endif
|
||||
default:
|
||||
ESP_LOGE(TAG, "%s: Incorrect param type (%u).",
|
||||
__FUNCTION__, (unsigned)param_type);
|
||||
err = ESP_ERR_NOT_SUPPORTED;
|
||||
break;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "esp_err.h" // for esp_err_t
|
||||
#include "mbc_master.h" // for master interface define
|
||||
#include "esp_modbus_master.h" // for public slave defines
|
||||
#include "mbc_serial_master.h" // for public interface defines
|
||||
|
||||
/**
|
||||
* Initialization of Modbus master serial
|
||||
*/
|
||||
esp_err_t mbc_master_init(mb_port_type_t port_type, void** handler)
|
||||
{
|
||||
void* port_handler = NULL;
|
||||
esp_err_t error = ESP_ERR_NOT_SUPPORTED;
|
||||
switch(port_type)
|
||||
{
|
||||
case MB_PORT_SERIAL_MASTER:
|
||||
error = mbc_serial_master_create(&port_handler);
|
||||
break;
|
||||
default:
|
||||
return ESP_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
if ((port_handler != NULL) && (error == ESP_OK)) {
|
||||
mbc_master_init_iface(port_handler);
|
||||
*handler = port_handler;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "esp_err.h" // for esp_err_t
|
||||
#include "esp_modbus_master.h" // for public interface defines
|
||||
#include "mbc_tcp_master.h" // for public interface defines
|
||||
|
||||
/**
|
||||
* Initialization of Modbus TCP Master controller interface
|
||||
*/
|
||||
esp_err_t mbc_master_init_tcp(void** handler)
|
||||
{
|
||||
void* port_handler = NULL;
|
||||
esp_err_t error = mbc_tcp_master_create(&port_handler);
|
||||
|
||||
if ((port_handler != NULL) && (error == ESP_OK)) {
|
||||
mbc_master_init_iface(port_handler);
|
||||
*handler = port_handler;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
@@ -0,0 +1,530 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "esp_err.h" // for esp_err_t
|
||||
#include "esp_timer.h" // for esp_timer_get_time()
|
||||
#include "sdkconfig.h" // for KConfig defines
|
||||
|
||||
#include "mbc_slave.h" // for slave private type definitions
|
||||
#include "mbutils.h" // for stack bit setting utilities
|
||||
#include "esp_modbus_common.h" // for common defines
|
||||
#include "esp_modbus_slave.h" // for public slave defines
|
||||
#include "esp_modbus_callbacks.h" // for modbus callbacks function pointers declaration
|
||||
|
||||
#ifdef CONFIG_FMB_CONTROLLER_SLAVE_ID_SUPPORT
|
||||
|
||||
#define MB_ID_BYTE0(id) ((uint8_t)(id))
|
||||
#define MB_ID_BYTE1(id) ((uint8_t)(((uint16_t)(id) >> 8) & 0xFF))
|
||||
#define MB_ID_BYTE2(id) ((uint8_t)(((uint32_t)(id) >> 16) & 0xFF))
|
||||
#define MB_ID_BYTE3(id) ((uint8_t)(((uint32_t)(id) >> 24) & 0xFF))
|
||||
|
||||
#define MB_CONTROLLER_SLAVE_ID (CONFIG_FMB_CONTROLLER_SLAVE_ID)
|
||||
#define MB_SLAVE_ID_SHORT (MB_ID_BYTE3(MB_CONTROLLER_SLAVE_ID))
|
||||
|
||||
// Slave ID constant
|
||||
static uint8_t mb_slave_id[] = { MB_ID_BYTE0(MB_CONTROLLER_SLAVE_ID),
|
||||
MB_ID_BYTE1(MB_CONTROLLER_SLAVE_ID),
|
||||
MB_ID_BYTE2(MB_CONTROLLER_SLAVE_ID) };
|
||||
|
||||
#endif
|
||||
|
||||
#define REG_SIZE(type, nregs) ((type == MB_PARAM_INPUT) || (type == MB_PARAM_HOLDING)) ? (nregs >> 1) : (nregs << 3)
|
||||
|
||||
// Common interface pointer for slave port
|
||||
static mb_slave_interface_t* slave_interface_ptr = NULL;
|
||||
static const char TAG[] __attribute__((unused)) = "MB_CONTROLLER_SLAVE";
|
||||
|
||||
// Searches the register in the area specified by type, returns descriptor if found, else NULL
|
||||
static mb_descr_entry_t* mbc_slave_find_reg_descriptor(mb_param_type_t type, uint16_t addr, size_t regs)
|
||||
{
|
||||
mb_descr_entry_t* it;
|
||||
uint16_t reg_size = 0;
|
||||
|
||||
mb_slave_options_t* mbs_opts = &slave_interface_ptr->opts;
|
||||
|
||||
if (LIST_EMPTY(&mbs_opts->mbs_area_descriptors[type])) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// search for the register in each area
|
||||
for (it = LIST_FIRST(&mbs_opts->mbs_area_descriptors[type]); it != NULL; it = LIST_NEXT(it, entries)) {
|
||||
reg_size = REG_SIZE(type, it->size);
|
||||
if ((addr >= it->start_offset)
|
||||
&& (it->p_data)
|
||||
&& (regs >= 1)
|
||||
&& ((addr + regs) <= (it->start_offset + reg_size))
|
||||
&& (reg_size >= 1)) {
|
||||
return it;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void mbc_slave_free_descriptors(void) {
|
||||
|
||||
mb_descr_entry_t* it;
|
||||
mb_slave_options_t* mbs_opts = &slave_interface_ptr->opts;
|
||||
|
||||
for (int descr_type = 0; descr_type < MB_PARAM_COUNT; descr_type++) {
|
||||
while ((it = LIST_FIRST(&mbs_opts->mbs_area_descriptors[descr_type]))) {
|
||||
LIST_REMOVE(it, entries);
|
||||
free(it);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void mbc_slave_init_iface(void* handler)
|
||||
{
|
||||
slave_interface_ptr = (mb_slave_interface_t*) handler;
|
||||
mb_slave_options_t* mbs_opts = &slave_interface_ptr->opts;
|
||||
// Initialize list head for register areas
|
||||
LIST_INIT(&mbs_opts->mbs_area_descriptors[MB_PARAM_INPUT]);
|
||||
LIST_INIT(&mbs_opts->mbs_area_descriptors[MB_PARAM_HOLDING]);
|
||||
LIST_INIT(&mbs_opts->mbs_area_descriptors[MB_PARAM_COIL]);
|
||||
LIST_INIT(&mbs_opts->mbs_area_descriptors[MB_PARAM_DISCRETE]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modbus controller destroy function
|
||||
*/
|
||||
esp_err_t mbc_slave_destroy(void)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
// Is initialization done?
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
// Check if interface has been initialized
|
||||
MB_SLAVE_CHECK((slave_interface_ptr->destroy != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
// Call the slave port destroy function
|
||||
error = slave_interface_ptr->destroy();
|
||||
MB_SLAVE_CHECK((error == ESP_OK),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave destroy failure error=(0x%x).",
|
||||
(int)error);
|
||||
// Destroy all opened descriptors
|
||||
mbc_slave_free_descriptors();
|
||||
free(slave_interface_ptr);
|
||||
slave_interface_ptr = NULL;
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Setup Modbus controller parameters
|
||||
*/
|
||||
esp_err_t mbc_slave_setup(void* comm_info)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
MB_SLAVE_CHECK((slave_interface_ptr->setup != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
error = slave_interface_ptr->setup(comm_info);
|
||||
MB_SLAVE_CHECK((error == ESP_OK),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave setup failure error=(0x%x).",
|
||||
(int)error);
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start Modbus controller start function
|
||||
*/
|
||||
esp_err_t mbc_slave_start(void)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
MB_SLAVE_CHECK((slave_interface_ptr->start != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
#ifdef CONFIG_FMB_CONTROLLER_SLAVE_ID_SUPPORT
|
||||
// Set the slave ID if the KConfig option is selected
|
||||
eMBErrorCode status = eMBSetSlaveID(MB_SLAVE_ID_SHORT, TRUE, (UCHAR*)mb_slave_id, sizeof(mb_slave_id));
|
||||
MB_SLAVE_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE, "mb stack set slave ID failure.");
|
||||
#endif
|
||||
error = slave_interface_ptr->start();
|
||||
MB_SLAVE_CHECK((error == ESP_OK),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave start failure error=(0x%x).",
|
||||
(int)error);
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Blocking function to get event on parameter group change for application task
|
||||
*/
|
||||
mb_event_group_t mbc_slave_check_event(mb_event_group_t group)
|
||||
{
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
MB_EVENT_NO_EVENTS,
|
||||
"Slave interface is not correctly initialized.");
|
||||
MB_SLAVE_CHECK((slave_interface_ptr->check_event != NULL),
|
||||
MB_EVENT_NO_EVENTS,
|
||||
"Slave interface is not correctly initialized.");
|
||||
mb_event_group_t event = slave_interface_ptr->check_event(group);
|
||||
return event;
|
||||
}
|
||||
|
||||
/**
|
||||
* Function to get notification about parameter change from application task
|
||||
*/
|
||||
esp_err_t mbc_slave_get_param_info(mb_param_info_t* reg_info, uint32_t timeout)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
MB_SLAVE_CHECK((slave_interface_ptr->get_param_info != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
error = slave_interface_ptr->get_param_info(reg_info, timeout);
|
||||
MB_SLAVE_CHECK((error == ESP_OK),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave get parameter info failure error=(0x%x).",
|
||||
(int)error);
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Function to set area descriptors for modbus parameters
|
||||
*/
|
||||
esp_err_t mbc_slave_set_descriptor(mb_register_area_descriptor_t descr_data)
|
||||
{
|
||||
esp_err_t error = ESP_OK;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
|
||||
if (slave_interface_ptr->set_descriptor != NULL) {
|
||||
error = slave_interface_ptr->set_descriptor(descr_data);
|
||||
MB_SLAVE_CHECK((error == ESP_OK),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave set descriptor failure error=(0x%x).",
|
||||
(int)error);
|
||||
} else {
|
||||
mb_slave_options_t* mbs_opts = &slave_interface_ptr->opts;
|
||||
// Check if the address is already in the descriptor list
|
||||
mb_descr_entry_t* it = mbc_slave_find_reg_descriptor(descr_data.type, descr_data.start_offset, 1);
|
||||
MB_SLAVE_CHECK((it == NULL), ESP_ERR_INVALID_ARG, "mb incorrect descriptor or already defined.");
|
||||
|
||||
mb_descr_entry_t* new_descr = (mb_descr_entry_t*) heap_caps_malloc(sizeof(mb_descr_entry_t),
|
||||
MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
|
||||
MB_SLAVE_CHECK((new_descr != NULL), ESP_ERR_NO_MEM, "mb can not allocate memory for descriptor.");
|
||||
new_descr->start_offset = descr_data.start_offset;
|
||||
new_descr->type = descr_data.type;
|
||||
new_descr->p_data = descr_data.address;
|
||||
new_descr->size = descr_data.size;
|
||||
LIST_INSERT_HEAD(&mbs_opts->mbs_area_descriptors[descr_data.type], new_descr, entries);
|
||||
error = ESP_OK;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
// The helper function to get time stamp in microseconds
|
||||
static uint64_t mbc_slave_get_time_stamp(void)
|
||||
{
|
||||
uint64_t time_stamp = esp_timer_get_time();
|
||||
return time_stamp;
|
||||
}
|
||||
|
||||
// Helper function to send parameter information to application task
|
||||
static esp_err_t mbc_slave_send_param_info(mb_event_group_t par_type, uint16_t mb_offset,
|
||||
uint8_t* par_address, uint16_t par_size)
|
||||
{
|
||||
MB_SLAVE_ASSERT(slave_interface_ptr != NULL);
|
||||
mb_slave_options_t* mbs_opts = &slave_interface_ptr->opts;
|
||||
esp_err_t error = ESP_FAIL;
|
||||
mb_param_info_t par_info;
|
||||
// Check if queue is not full the send parameter information
|
||||
par_info.type = par_type;
|
||||
par_info.size = par_size;
|
||||
par_info.address = par_address;
|
||||
par_info.time_stamp = mbc_slave_get_time_stamp();
|
||||
par_info.mb_offset = mb_offset;
|
||||
BaseType_t status = xQueueSend(mbs_opts->mbs_notification_queue_handle, &par_info, MB_PAR_INFO_TOUT);
|
||||
if (pdTRUE == status) {
|
||||
ESP_LOGD(TAG, "Queue send parameter info (type, address, size): %d, 0x%" PRIx32 ", %u",
|
||||
(int)par_type, (uint32_t)par_address, (unsigned)par_size);
|
||||
error = ESP_OK;
|
||||
} else if (errQUEUE_FULL == status) {
|
||||
ESP_LOGD(TAG, "Parameter queue is overflowed.");
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
// Helper function to send notification
|
||||
static esp_err_t mbc_slave_send_param_access_notification(mb_event_group_t event)
|
||||
{
|
||||
MB_SLAVE_ASSERT(slave_interface_ptr != NULL);
|
||||
mb_slave_options_t* mbs_opts = &slave_interface_ptr->opts;
|
||||
esp_err_t err = ESP_FAIL;
|
||||
mb_event_group_t bits = (mb_event_group_t)xEventGroupSetBits(mbs_opts->mbs_event_group, (EventBits_t)event);
|
||||
if (bits & event) {
|
||||
ESP_LOGD(TAG, "The MB_REG_CHANGE_EVENT = 0x%.2x is set.", (int)event);
|
||||
err = ESP_OK;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Below are the common slave read/write register callback functions
|
||||
* The concrete slave port can override them using interface function pointers
|
||||
*/
|
||||
|
||||
// Callback function for reading of MB Input Registers
|
||||
eMBErrorCode mbc_reg_input_slave_cb(UCHAR * reg_buffer, USHORT address, USHORT n_regs)
|
||||
{
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
MB_EILLSTATE, "Slave stack uninitialized.");
|
||||
MB_SLAVE_CHECK((reg_buffer != NULL),
|
||||
MB_EINVAL, "Slave stack call failed.");
|
||||
eMBErrorCode status = MB_ENOERR;
|
||||
address--; // address of register is already +1
|
||||
mb_descr_entry_t* it = mbc_slave_find_reg_descriptor(MB_PARAM_INPUT, address, n_regs);
|
||||
if (it != NULL) {
|
||||
uint16_t input_reg_start = (uint16_t)it->start_offset; // Get Modbus start address
|
||||
uint8_t* input_buffer = (uint8_t*)it->p_data; // Get instance address
|
||||
uint16_t regs = n_regs;
|
||||
uint16_t reg_index;
|
||||
// If input or configuration parameters are incorrect then return an error to stack layer
|
||||
reg_index = (uint16_t)(address - input_reg_start);
|
||||
reg_index <<= 1; // register Address to byte address
|
||||
input_buffer += reg_index;
|
||||
uint8_t* buffer_start = input_buffer;
|
||||
while (regs > 0) {
|
||||
_XFER_2_RD(reg_buffer, input_buffer);
|
||||
reg_index += 2;
|
||||
regs -= 1;
|
||||
}
|
||||
// Send access notification
|
||||
(void)mbc_slave_send_param_access_notification(MB_EVENT_INPUT_REG_RD);
|
||||
// Send parameter info to application task
|
||||
(void)mbc_slave_send_param_info(MB_EVENT_INPUT_REG_RD, (uint16_t)address,
|
||||
(uint8_t*)buffer_start, (uint16_t)n_regs);
|
||||
} else {
|
||||
status = MB_ENOREG;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// Callback function for reading of MB Holding Registers
|
||||
// Executed by stack when request to read/write holding registers is received
|
||||
eMBErrorCode mbc_reg_holding_slave_cb(UCHAR * reg_buffer, USHORT address, USHORT n_regs, eMBRegisterMode mode)
|
||||
{
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
MB_EILLSTATE, "Slave stack uninitialized.");
|
||||
MB_SLAVE_CHECK((reg_buffer != NULL),
|
||||
MB_EINVAL, "Slave stack call failed.");
|
||||
eMBErrorCode status = MB_ENOERR;
|
||||
uint16_t reg_index;
|
||||
address--; // address of register is already +1
|
||||
mb_descr_entry_t* it = mbc_slave_find_reg_descriptor(MB_PARAM_HOLDING, address, n_regs);
|
||||
if (it != NULL) {
|
||||
uint16_t reg_holding_start = (uint16_t)it->start_offset; // Get Modbus start address
|
||||
uint8_t* holding_buffer = (uint8_t*)it->p_data; // Get instance address
|
||||
uint16_t regs = n_regs;
|
||||
reg_index = (uint16_t) (address - reg_holding_start);
|
||||
reg_index <<= 1; // register Address to byte address
|
||||
holding_buffer += reg_index;
|
||||
uint8_t* buffer_start = holding_buffer;
|
||||
switch (mode) {
|
||||
case MB_REG_READ:
|
||||
while (regs > 0) {
|
||||
_XFER_2_RD(reg_buffer, holding_buffer);
|
||||
reg_index += 2;
|
||||
regs -= 1;
|
||||
};
|
||||
// Send access notification
|
||||
(void)mbc_slave_send_param_access_notification(MB_EVENT_HOLDING_REG_RD);
|
||||
// Send parameter info
|
||||
(void)mbc_slave_send_param_info(MB_EVENT_HOLDING_REG_RD, (uint16_t)address,
|
||||
(uint8_t*)buffer_start, (uint16_t)n_regs);
|
||||
break;
|
||||
case MB_REG_WRITE:
|
||||
while (regs > 0) {
|
||||
_XFER_2_WR(holding_buffer, reg_buffer);
|
||||
holding_buffer += 2;
|
||||
reg_index += 2;
|
||||
regs -= 1;
|
||||
};
|
||||
// Send access notification
|
||||
(void)mbc_slave_send_param_access_notification(MB_EVENT_HOLDING_REG_WR);
|
||||
// Send parameter info
|
||||
(void)mbc_slave_send_param_info(MB_EVENT_HOLDING_REG_WR, (uint16_t)address,
|
||||
(uint8_t*)buffer_start, (uint16_t)n_regs);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
status = MB_ENOREG;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// Callback function for reading of MB Coils Registers
|
||||
eMBErrorCode mbc_reg_coils_slave_cb(UCHAR* reg_buffer, USHORT address, USHORT n_coils, eMBRegisterMode mode)
|
||||
{
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
MB_EILLSTATE, "Slave stack uninitialized.");
|
||||
MB_SLAVE_CHECK((reg_buffer != NULL),
|
||||
MB_EINVAL, "Slave stack call failed.");
|
||||
eMBErrorCode status = MB_ENOERR;
|
||||
uint16_t reg_index;
|
||||
uint16_t coils = n_coils;
|
||||
address--; // The address is already +1
|
||||
mb_descr_entry_t* it = mbc_slave_find_reg_descriptor(MB_PARAM_COIL, address, n_coils);
|
||||
if (it != NULL) {
|
||||
uint16_t reg_coils_start = (uint16_t)it->start_offset; // MB offset of coils
|
||||
uint8_t* reg_coils_buf = (uint8_t*)it->p_data;
|
||||
reg_index = (uint16_t) (address - it->start_offset);
|
||||
CHAR* coils_data_buf = (CHAR*)(reg_coils_buf + (reg_index >> 3));
|
||||
switch (mode) {
|
||||
case MB_REG_READ:
|
||||
while (coils > 0) {
|
||||
uint8_t result = xMBUtilGetBits((uint8_t*)reg_coils_buf, reg_index, 1);
|
||||
xMBUtilSetBits(reg_buffer, reg_index - (address - reg_coils_start), 1, result);
|
||||
reg_index++;
|
||||
coils--;
|
||||
}
|
||||
// Send an event to notify application task about event
|
||||
(void)mbc_slave_send_param_access_notification(MB_EVENT_COILS_RD);
|
||||
(void)mbc_slave_send_param_info(MB_EVENT_COILS_RD, (uint16_t)address,
|
||||
(uint8_t*)(coils_data_buf), (uint16_t)n_coils);
|
||||
break;
|
||||
case MB_REG_WRITE:
|
||||
while (coils > 0) {
|
||||
uint8_t result = xMBUtilGetBits(reg_buffer,
|
||||
reg_index - (address - reg_coils_start), 1);
|
||||
xMBUtilSetBits((uint8_t*)reg_coils_buf, reg_index, 1, result);
|
||||
reg_index++;
|
||||
coils--;
|
||||
}
|
||||
// Send an event to notify application task about event
|
||||
(void)mbc_slave_send_param_access_notification(MB_EVENT_COILS_WR);
|
||||
(void)mbc_slave_send_param_info(MB_EVENT_COILS_WR, (uint16_t)address,
|
||||
(uint8_t*)coils_data_buf, (uint16_t)n_coils);
|
||||
break;
|
||||
} // switch ( eMode )
|
||||
} else {
|
||||
// If the configuration or input parameters are incorrect then return error to stack
|
||||
status = MB_ENOREG;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// Callback function for reading of MB Discrete Input Registers
|
||||
eMBErrorCode mbc_reg_discrete_slave_cb(UCHAR* reg_buffer, USHORT address, USHORT n_discrete)
|
||||
{
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
MB_EILLSTATE, "Slave stack uninitialized.");
|
||||
MB_SLAVE_CHECK((reg_buffer != NULL),
|
||||
MB_EINVAL, "Slave stack call failed.");
|
||||
|
||||
eMBErrorCode status = MB_ENOERR;
|
||||
uint16_t reg_index;
|
||||
uint16_t reg_bit_index;
|
||||
uint16_t n_reg;
|
||||
uint8_t* discrete_input_buf;
|
||||
// It already plus one in modbus function method.
|
||||
address--;
|
||||
mb_descr_entry_t* it = mbc_slave_find_reg_descriptor(MB_PARAM_DISCRETE, address, n_discrete);
|
||||
if (it != NULL) {
|
||||
uint16_t reg_discrete_start = (uint16_t)it->start_offset; // MB offset of registers
|
||||
n_reg = (n_discrete >> 3) + 1;
|
||||
discrete_input_buf = (uint8_t*)it->p_data; // the storage address
|
||||
reg_index = (uint16_t) (address - reg_discrete_start) / 8; // Get register index in the buffer for bit number
|
||||
reg_bit_index = (uint16_t)(address - reg_discrete_start) % 8; // Get bit index
|
||||
uint8_t* temp_buf = &discrete_input_buf[reg_index];
|
||||
while (n_reg > 0) {
|
||||
*reg_buffer++ = xMBUtilGetBits(&discrete_input_buf[reg_index++], reg_bit_index, 8);
|
||||
n_reg--;
|
||||
}
|
||||
reg_buffer--;
|
||||
// Last discrete
|
||||
n_discrete = n_discrete % 8;
|
||||
// Filling zero to high bit
|
||||
*reg_buffer = *reg_buffer << (8 - n_discrete);
|
||||
*reg_buffer = *reg_buffer >> (8 - n_discrete);
|
||||
// Send an event to notify application task about event
|
||||
(void)mbc_slave_send_param_access_notification(MB_EVENT_DISCRETE_RD);
|
||||
(void)mbc_slave_send_param_info(MB_EVENT_DISCRETE_RD, (uint16_t)address,
|
||||
(uint8_t*)temp_buf, (uint16_t)n_discrete);
|
||||
} else {
|
||||
status = MB_ENOREG;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* Below are the stack callback functions to read/write registers
|
||||
*/
|
||||
eMBErrorCode eMBRegDiscreteCB(UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
// Check if the callback is overridden in concrete port
|
||||
if (slave_interface_ptr->slave_reg_cb_discrete) {
|
||||
error = slave_interface_ptr->slave_reg_cb_discrete(pucRegBuffer, usAddress, usNDiscrete);
|
||||
} else {
|
||||
error = mbc_reg_discrete_slave_cb(pucRegBuffer, usAddress, usNDiscrete);
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBRegCoilsCB(UCHAR* pucRegBuffer, USHORT usAddress,
|
||||
USHORT usNCoils, eMBRegisterMode eMode)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
|
||||
if (slave_interface_ptr->slave_reg_cb_coils) {
|
||||
error = slave_interface_ptr->slave_reg_cb_coils(pucRegBuffer, usAddress, usNCoils, eMode);
|
||||
} else {
|
||||
error = mbc_reg_coils_slave_cb(pucRegBuffer, usAddress, usNCoils, eMode);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBRegHoldingCB(UCHAR * pucRegBuffer, USHORT usAddress,
|
||||
USHORT usNRegs, eMBRegisterMode eMode)
|
||||
{
|
||||
eMBErrorCode error = MB_ENOERR;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
|
||||
if (slave_interface_ptr->slave_reg_cb_holding) {
|
||||
error = slave_interface_ptr->slave_reg_cb_holding(pucRegBuffer, usAddress, usNRegs, eMode);
|
||||
} else {
|
||||
error = mbc_reg_holding_slave_cb(pucRegBuffer, usAddress, usNRegs, eMode);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
eMBErrorCode eMBRegInputCB(UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs)
|
||||
{
|
||||
eMBErrorCode error = ESP_ERR_INVALID_STATE;
|
||||
MB_SLAVE_CHECK((slave_interface_ptr != NULL),
|
||||
ESP_ERR_INVALID_STATE,
|
||||
"Slave interface is not correctly initialized.");
|
||||
|
||||
if (slave_interface_ptr->slave_reg_cb_input) {
|
||||
error = slave_interface_ptr->slave_reg_cb_input(pucRegBuffer, usAddress, usNRegs);
|
||||
} else {
|
||||
error = mbc_reg_input_slave_cb(pucRegBuffer, usAddress, usNRegs);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "esp_err.h" // for esp_err_t
|
||||
#include "sdkconfig.h" // for KConfig defines
|
||||
#include "mbc_slave.h" // for slave interface define
|
||||
#include "esp_modbus_slave.h" // for public slave defines
|
||||
#include "mbc_serial_slave.h" // for public interface defines
|
||||
|
||||
/**
|
||||
* Initialization of Modbus Serial slave controller
|
||||
*/
|
||||
esp_err_t mbc_slave_init(mb_port_type_t port_type, void** handler)
|
||||
{
|
||||
void* port_handler = NULL;
|
||||
esp_err_t error = ESP_ERR_NOT_SUPPORTED;
|
||||
switch(port_type)
|
||||
{
|
||||
case MB_PORT_SERIAL_SLAVE:
|
||||
// Call constructor function of actual port implementation
|
||||
error = mbc_serial_slave_create(&port_handler);
|
||||
break;
|
||||
default:
|
||||
return ESP_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
if ((port_handler != NULL) && (error == ESP_OK)) {
|
||||
mbc_slave_init_iface(port_handler);
|
||||
*handler = port_handler;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "esp_err.h" // for esp_err_t
|
||||
#include "esp_modbus_slave.h" // for public slave defines
|
||||
#include "mbc_tcp_slave.h" // for public interface defines
|
||||
|
||||
/**
|
||||
* Initialization of Modbus TCP Slave controller
|
||||
*/
|
||||
esp_err_t mbc_slave_init_tcp(void** handler)
|
||||
{
|
||||
void* port_handler = NULL;
|
||||
esp_err_t error = mbc_tcp_slave_create(&port_handler);
|
||||
|
||||
if ((port_handler != NULL) && (error == ESP_OK)) {
|
||||
mbc_slave_init_iface(port_handler);
|
||||
*handler = port_handler;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#ifndef _MB_IFACE_COMMON_H
|
||||
#define _MB_IFACE_COMMON_H
|
||||
|
||||
#include <inttypes.h> // needs to be included for default system types (such as PRIxx)
|
||||
#include "driver/uart.h" // for UART types
|
||||
#include "sdkconfig.h"
|
||||
|
||||
#if CONFIG_FMB_EXT_TYPE_SUPPORT
|
||||
#include "mb_endianness_utils.h"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if __has_include("esp_check.h")
|
||||
#include "esp_check.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
#define MB_RETURN_ON_FALSE(a, err_code, tag, format, ...) ESP_RETURN_ON_FALSE(a, err_code, tag, format __VA_OPT__(,) __VA_ARGS__)
|
||||
|
||||
#else
|
||||
|
||||
// if cannot include esp_check then use custom check macro
|
||||
|
||||
#define MB_RETURN_ON_FALSE(a, err_code, tag, format, ...) do { \
|
||||
if (!(a)) { \
|
||||
ESP_LOGE(tag, "%s(%" PRIu32 "): " format, __FUNCTION__, __LINE__ __VA_OPT__(,) __VA_ARGS__); \
|
||||
return err_code; \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
#endif
|
||||
|
||||
#define MB_CONTROLLER_STACK_SIZE (CONFIG_FMB_CONTROLLER_STACK_SIZE) // Stack size for Modbus controller
|
||||
#define MB_CONTROLLER_PRIORITY (CONFIG_FMB_PORT_TASK_PRIO - 1) // priority of MB controller task
|
||||
|
||||
// Default port defines
|
||||
#define MB_DEVICE_ADDRESS (1) // Default slave device address in Modbus
|
||||
#define MB_DEVICE_SPEED (115200) // Default Modbus speed for now hard defined
|
||||
#define MB_UART_PORT (UART_NUM_MAX - 1) // Default UART port number
|
||||
#define MB_PAR_INFO_TOUT (10) // Timeout for get parameter info
|
||||
#define MB_PARITY_NONE (UART_PARITY_DISABLE)
|
||||
|
||||
// The Macros below handle the endianness while transfer N byte data into buffer (convert from network byte order)
|
||||
#define _XFER_2_RD(dst, src) { \
|
||||
*(uint8_t *)(dst)++ = *(uint8_t *)(src + 1); \
|
||||
*(uint8_t *)(dst)++ = *(uint8_t *)(src + 0); \
|
||||
(src) += 2; \
|
||||
}
|
||||
|
||||
#define _XFER_2_WR(dst, src) { \
|
||||
*(uint8_t *)(dst + 1) = *(uint8_t *)(src)++; \
|
||||
*(uint8_t *)(dst + 0) = *(uint8_t *)(src)++; \
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Types of actual Modbus implementation
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
MB_PORT_SERIAL_MASTER = 0x00, /*!< Modbus port type serial master. */
|
||||
MB_PORT_SERIAL_SLAVE, /*!< Modbus port type serial slave. */
|
||||
MB_PORT_TCP_MASTER, /*!< Modbus port type TCP master. */
|
||||
MB_PORT_TCP_SLAVE, /*!< Modbus port type TCP slave. */
|
||||
MB_PORT_COUNT, /*!< Modbus port count. */
|
||||
MB_PORT_INACTIVE = 0xFF
|
||||
} mb_port_type_t;
|
||||
|
||||
/**
|
||||
* @brief Event group for parameters notification
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
MB_EVENT_NO_EVENTS = 0x00,
|
||||
MB_EVENT_HOLDING_REG_WR = BIT0, /*!< Modbus Event Write Holding registers. */
|
||||
MB_EVENT_HOLDING_REG_RD = BIT1, /*!< Modbus Event Read Holding registers. */
|
||||
MB_EVENT_INPUT_REG_RD = BIT3, /*!< Modbus Event Read Input registers. */
|
||||
MB_EVENT_COILS_WR = BIT4, /*!< Modbus Event Write Coils. */
|
||||
MB_EVENT_COILS_RD = BIT5, /*!< Modbus Event Read Coils. */
|
||||
MB_EVENT_DISCRETE_RD = BIT6, /*!< Modbus Event Read Discrete bits. */
|
||||
MB_EVENT_STACK_STARTED = BIT7 /*!< Modbus Event Stack started */
|
||||
} mb_event_group_t;
|
||||
|
||||
/**
|
||||
* @brief Type of Modbus parameter
|
||||
*/
|
||||
typedef enum {
|
||||
MB_PARAM_HOLDING = 0x00, /*!< Modbus Holding register. */
|
||||
MB_PARAM_INPUT, /*!< Modbus Input register. */
|
||||
MB_PARAM_COIL, /*!< Modbus Coils. */
|
||||
MB_PARAM_DISCRETE, /*!< Modbus Discrete bits. */
|
||||
MB_PARAM_COUNT,
|
||||
MB_PARAM_UNKNOWN = 0xFF
|
||||
} mb_param_type_t;
|
||||
|
||||
/*!
|
||||
* \brief Modbus serial transmission modes (RTU/ASCII).
|
||||
*/
|
||||
typedef enum {
|
||||
MB_MODE_RTU, /*!< RTU transmission mode. */
|
||||
MB_MODE_ASCII, /*!< ASCII transmission mode. */
|
||||
MB_MODE_TCP, /*!< TCP communication mode. */
|
||||
MB_MODE_UDP /*!< UDP communication mode. */
|
||||
} mb_mode_type_t;
|
||||
|
||||
/*!
|
||||
* \brief Modbus TCP type of address.
|
||||
*/
|
||||
typedef enum {
|
||||
MB_IPV4 = 0, /*!< TCP IPV4 addressing */
|
||||
MB_IPV6 = 1 /*!< TCP IPV6 addressing */
|
||||
} mb_tcp_addr_type_t;
|
||||
|
||||
/**
|
||||
* @brief Device communication structure to setup Modbus controller
|
||||
*/
|
||||
typedef union {
|
||||
// Serial communication structure
|
||||
struct {
|
||||
mb_mode_type_t mode; /*!< Modbus communication mode */
|
||||
uint8_t slave_addr; /*!< Modbus slave address field (dummy for master) */
|
||||
uart_port_t port; /*!< Modbus communication port (UART) number */
|
||||
uint32_t baudrate; /*!< Modbus baudrate */
|
||||
uart_parity_t parity; /*!< Modbus UART parity settings */
|
||||
uint16_t dummy_port; /*!< Dummy field, unused */
|
||||
};
|
||||
// TCP/UDP communication structure
|
||||
struct {
|
||||
mb_mode_type_t ip_mode; /*!< Modbus communication mode */
|
||||
uint8_t slave_uid; /*!< Modbus slave address field for UID */
|
||||
uint16_t ip_port; /*!< Modbus port */
|
||||
mb_tcp_addr_type_t ip_addr_type; /*!< Modbus address type */
|
||||
void* ip_addr; /*!< Modbus address table for connection */
|
||||
void* ip_netif_ptr; /*!< Modbus network interface */
|
||||
};
|
||||
} mb_communication_info_t;
|
||||
|
||||
/**
|
||||
* common interface method types
|
||||
*/
|
||||
typedef esp_err_t (*iface_init)(void**); /*!< Interface method init */
|
||||
typedef esp_err_t (*iface_destroy)(void); /*!< Interface method destroy */
|
||||
typedef esp_err_t (*iface_setup)(void*); /*!< Interface method setup */
|
||||
typedef esp_err_t (*iface_start)(void); /*!< Interface method start */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // _MB_IFACE_COMMON_H
|
||||
@@ -0,0 +1,351 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#ifndef _ESP_MB_MASTER_INTERFACE_H
|
||||
#define _ESP_MB_MASTER_INTERFACE_H
|
||||
|
||||
#include <stdint.h> // for standard int types definition
|
||||
#include <stddef.h> // for NULL and std defines
|
||||
#include "soc/soc.h" // for BITN definitions
|
||||
#include "esp_modbus_common.h" // for common types
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define MB_MASTER_CHECK(a, err_code, format, ...) MB_RETURN_ON_FALSE(a, err_code, TAG, format __VA_OPT__(,) __VA_ARGS__)
|
||||
|
||||
#define MB_MASTER_ASSERT(con) do { \
|
||||
if (!(con)) { ESP_LOGE(TAG, "assert errno:%u, errno_str: !(%s)", (unsigned)errno, strerror(errno)); assert(0 && #con); } \
|
||||
} while (0)
|
||||
|
||||
/*!
|
||||
* \brief The macro to access arrays of elements for type conversion.
|
||||
*/
|
||||
#define MB_EACH_ELEM(psrc, pdest, arr_size, elem_size) \
|
||||
(int i = 0; (i < (arr_size / elem_size)); i++, pdest += elem_size, psrc += elem_size)
|
||||
|
||||
/*!
|
||||
* \brief Modbus descriptor table parameter type defines.
|
||||
*/
|
||||
typedef enum {
|
||||
PARAM_TYPE_U8 = 0x00, /*!< Unsigned 8 */
|
||||
PARAM_TYPE_U16 = 0x01, /*!< Unsigned 16 */
|
||||
PARAM_TYPE_U32 = 0x02, /*!< Unsigned 32 */
|
||||
PARAM_TYPE_FLOAT = 0x03, /*!< Float type */
|
||||
PARAM_TYPE_ASCII = 0x04, /*!< ASCII type */
|
||||
PARAM_TYPE_BIN = 0x07, /*!< BIN type */
|
||||
PARAM_TYPE_I8_A = 0x0A, /*!< I8 signed integer in high byte of register */
|
||||
PARAM_TYPE_I8_B = 0x0B, /*!< I8 signed integer in low byte of register */
|
||||
PARAM_TYPE_U8_A = 0x0C, /*!< U8 unsigned integer written to hi byte of register */
|
||||
PARAM_TYPE_U8_B = 0x0D, /*!< U8 unsigned integer written to low byte of register */
|
||||
PARAM_TYPE_I16_AB = 0x0E, /*!< I16 signed integer, big endian */
|
||||
PARAM_TYPE_I16_BA = 0x0F, /*!< I16 signed integer, little endian */
|
||||
PARAM_TYPE_U16_AB = 0x10, /*!< U16 unsigned integer, big endian*/
|
||||
PARAM_TYPE_U16_BA = 0x11, /*!< U16 unsigned integer, little endian */
|
||||
PARAM_TYPE_I32_ABCD = 0x12, /*!< I32 ABCD signed integer, big endian */
|
||||
PARAM_TYPE_I32_CDAB = 0x13, /*!< I32 CDAB signed integer, big endian, reversed register order */
|
||||
PARAM_TYPE_I32_BADC = 0x14, /*!< I32 BADC signed integer, little endian, reversed register order */
|
||||
PARAM_TYPE_I32_DCBA = 0x15, /*!< I32 DCBA signed integer, little endian */
|
||||
PARAM_TYPE_U32_ABCD = 0x16, /*!< U32 ABCD unsigned integer, big endian */
|
||||
PARAM_TYPE_U32_CDAB = 0x17, /*!< U32 CDAB unsigned integer, big endian, reversed register order */
|
||||
PARAM_TYPE_U32_BADC = 0x18, /*!< U32 BADC unsigned integer, little endian, reversed register order */
|
||||
PARAM_TYPE_U32_DCBA = 0x19, /*!< U32 DCBA unsigned integer, little endian */
|
||||
PARAM_TYPE_FLOAT_ABCD = 0x1A, /*!< Float ABCD floating point, big endian */
|
||||
PARAM_TYPE_FLOAT_CDAB = 0x1B, /*!< Float CDAB floating point big endian, reversed register order */
|
||||
PARAM_TYPE_FLOAT_BADC = 0x1C, /*!< Float BADC floating point, little endian, reversed register order */
|
||||
PARAM_TYPE_FLOAT_DCBA = 0x1D, /*!< Float DCBA floating point, little endian */
|
||||
PARAM_TYPE_I64_ABCDEFGH = 0x1E, /*!< I64, ABCDEFGH signed integer, big endian */
|
||||
PARAM_TYPE_I64_HGFEDCBA = 0x1F, /*!< I64, HGFEDCBA signed integer, little endian */
|
||||
PARAM_TYPE_I64_GHEFCDAB = 0x20, /*!< I64, GHEFCDAB signed integer, big endian, reversed register order */
|
||||
PARAM_TYPE_I64_BADCFEHG = 0x21, /*!< I64, BADCFEHG signed integer, little endian, reversed register order */
|
||||
PARAM_TYPE_U64_ABCDEFGH = 0x22, /*!< U64, ABCDEFGH unsigned integer, big endian */
|
||||
PARAM_TYPE_U64_HGFEDCBA = 0x23, /*!< U64, HGFEDCBA unsigned integer, little endian */
|
||||
PARAM_TYPE_U64_GHEFCDAB = 0x24, /*!< U64, GHEFCDAB unsigned integer, big endian, reversed register order */
|
||||
PARAM_TYPE_U64_BADCFEHG = 0x25, /*!< U64, BADCFEHG unsigned integer, little endian, reversed register order */
|
||||
PARAM_TYPE_DOUBLE_ABCDEFGH = 0x26, /*!< Double ABCDEFGH floating point, big endian*/
|
||||
PARAM_TYPE_DOUBLE_HGFEDCBA = 0x27, /*!< Double HGFEDCBA floating point, little endian*/
|
||||
PARAM_TYPE_DOUBLE_GHEFCDAB = 0x28, /*!< Double GHEFCDAB floating point, big endian, reversed register order */
|
||||
PARAM_TYPE_DOUBLE_BADCFEHG = 0x29 /*!< Double BADCFEHG floating point, little endian, reversed register order */
|
||||
} mb_descr_type_t;
|
||||
|
||||
/*!
|
||||
* \brief Modbus descriptor table parameter size in bytes.
|
||||
*/
|
||||
typedef enum {
|
||||
PARAM_SIZE_U8 = 0x01, /*!< Unsigned 8 */
|
||||
PARAM_SIZE_U8_REG = 0x02, /*!< Unsigned 8, register value */
|
||||
PARAM_SIZE_I8_REG = 0x02, /*!< Signed 8, register value */
|
||||
PARAM_SIZE_I16 = 0x02, /*!< Unsigned 16 */
|
||||
PARAM_SIZE_U16 = 0x02, /*!< Unsigned 16 */
|
||||
PARAM_SIZE_I32 = 0x04, /*!< Signed 32 */
|
||||
PARAM_SIZE_U32 = 0x04, /*!< Unsigned 32 */
|
||||
PARAM_SIZE_FLOAT = 0x04, /*!< Float 32 size */
|
||||
PARAM_SIZE_ASCII = 0x08, /*!< ASCII size default*/
|
||||
PARAM_SIZE_ASCII24 = 0x18, /*!< ASCII24 size */
|
||||
PARAM_SIZE_I64 = 0x08, /*!< Signed integer 64 size */
|
||||
PARAM_SIZE_U64 = 0x08, /*!< Unsigned integer 64 size */
|
||||
PARAM_SIZE_DOUBLE = 0x08, /*!< Double 64 size */
|
||||
PARAM_MAX_SIZE
|
||||
} mb_descr_size_t;
|
||||
|
||||
/*!
|
||||
* \brief Modbus parameter options for description table
|
||||
*/
|
||||
typedef union {
|
||||
struct {
|
||||
int opt1; /*!< Parameter option1 */
|
||||
int opt2; /*!< Parameter option2 */
|
||||
int opt3; /*!< Parameter option3 */
|
||||
};
|
||||
struct {
|
||||
int min; /*!< Parameter minimum value */
|
||||
int max; /*!< Parameter maximum value */
|
||||
int step; /*!< Step of parameter change tracking */
|
||||
};
|
||||
} mb_parameter_opt_t;
|
||||
|
||||
/**
|
||||
* @brief Permissions for the characteristics
|
||||
*/
|
||||
typedef enum {
|
||||
PAR_PERMS_READ = 1 << BIT0, /**< the characteristic of the device are readable */
|
||||
PAR_PERMS_WRITE = 1 << BIT1, /**< the characteristic of the device are writable*/
|
||||
PAR_PERMS_TRIGGER = 1 << BIT2, /**< the characteristic of the device are triggerable */
|
||||
PAR_PERMS_READ_WRITE = PAR_PERMS_READ | PAR_PERMS_WRITE, /**< the characteristic of the device are readable & writable */
|
||||
PAR_PERMS_READ_TRIGGER = PAR_PERMS_READ | PAR_PERMS_TRIGGER, /**< the characteristic of the device are readable & triggerable */
|
||||
PAR_PERMS_WRITE_TRIGGER = PAR_PERMS_WRITE | PAR_PERMS_TRIGGER, /**< the characteristic of the device are writable & triggerable */
|
||||
PAR_PERMS_READ_WRITE_TRIGGER = PAR_PERMS_READ_WRITE | PAR_PERMS_TRIGGER, /**< the characteristic of the device are readable & writable & triggerable */
|
||||
} mb_param_perms_t;
|
||||
|
||||
/**
|
||||
* @brief Characteristics descriptor type is used to describe characteristic and
|
||||
* link it with Modbus parameters that reflect its data.
|
||||
*/
|
||||
typedef struct {
|
||||
uint16_t cid; /*!< Characteristic cid */
|
||||
const char* param_key; /*!< The key (name) of the parameter */
|
||||
const char* param_units; /*!< The physical units of the parameter */
|
||||
uint8_t mb_slave_addr; /*!< Slave address of device in the Modbus segment */
|
||||
mb_param_type_t mb_param_type; /*!< Type of modbus parameter */
|
||||
uint16_t mb_reg_start; /*!< This is the Modbus register address. This is the 0 based value. */
|
||||
uint16_t mb_size; /*!< Size of mb parameter in registers */
|
||||
uint16_t param_offset; /*!< Parameter name (OFFSET in the parameter structure) */
|
||||
mb_descr_type_t param_type; /*!< Float, U8, U16, U32, ASCII, etc. */
|
||||
mb_descr_size_t param_size; /*!< Number of bytes in the parameter. */
|
||||
mb_parameter_opt_t param_opts; /*!< Parameter options used to check limits and etc. */
|
||||
mb_param_perms_t access; /*!< Access permissions based on mode */
|
||||
} mb_parameter_descriptor_t;
|
||||
|
||||
/**
|
||||
* @brief Modbus register request type structure
|
||||
*/
|
||||
typedef struct {
|
||||
uint8_t slave_addr; /*!< Modbus slave address */
|
||||
uint8_t command; /*!< Modbus command to send */
|
||||
uint16_t reg_start; /*!< Modbus start register */
|
||||
uint16_t reg_size; /*!< Modbus number of registers */
|
||||
} mb_param_request_t;
|
||||
|
||||
/**
|
||||
* @brief Modbus transacion info structure
|
||||
*/
|
||||
typedef struct {
|
||||
uint64_t trans_id; /*!< Modbus unique transaction identificator */
|
||||
uint16_t err_type; /*!< Modbus last transaction error type */
|
||||
uint8_t dest_addr; /*!< Modbus destination short address (or UID) */
|
||||
uint8_t func_code; /*!< Modbus last transaction function code */
|
||||
uint8_t exception; /*!< Modbus last transaction exception code returned by slave */
|
||||
} mb_trans_info_t;
|
||||
|
||||
/**
|
||||
* @brief Initialize Modbus controller and stack for TCP port
|
||||
*
|
||||
* @param[out] handler handler(pointer) to master data structure
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_NO_MEM Parameter error
|
||||
* - ESP_ERR_NOT_SUPPORTED Port type not supported
|
||||
* - ESP_ERR_INVALID_STATE Initialization failure
|
||||
*/
|
||||
esp_err_t mbc_master_init_tcp(void** handler);
|
||||
|
||||
/**
|
||||
* @brief Initialize Modbus Master controller and stack for Serial port
|
||||
*
|
||||
* @param[out] handler handler(pointer) to master data structure
|
||||
* @param[in] port_type type of stack
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_NO_MEM Parameter error
|
||||
* - ESP_ERR_NOT_SUPPORTED Port type not supported
|
||||
* - ESP_ERR_INVALID_STATE Initialization failure
|
||||
*/
|
||||
esp_err_t mbc_master_init(mb_port_type_t port_type, void** handler);
|
||||
|
||||
/**
|
||||
* @brief Initialize Modbus Master controller interface handle
|
||||
*
|
||||
* @param[in] handler - pointer to master data structure
|
||||
*/
|
||||
void mbc_master_init_iface(void* handler);
|
||||
|
||||
/**
|
||||
* @brief Destroy Modbus controller and stack
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_INVALID_STATE Parameter error
|
||||
*/
|
||||
esp_err_t mbc_master_destroy(void);
|
||||
|
||||
/**
|
||||
* @brief Start Modbus communication stack
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_INVALID_ARG Modbus stack start error
|
||||
*/
|
||||
esp_err_t mbc_master_start(void);
|
||||
|
||||
/**
|
||||
* @brief Set Modbus communication parameters for the controller
|
||||
*
|
||||
* @param comm_info Communication parameters structure.
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_INVALID_ARG Incorrect parameter data
|
||||
*/
|
||||
esp_err_t mbc_master_setup(void* comm_info);
|
||||
|
||||
/***************************** Specific interface functions ********************************************
|
||||
* Interface functions below provide basic methods to read/write access to slave devices in Modbus
|
||||
* segment as well as API to read specific supported characteristics linked to Modbus parameters
|
||||
* of devices in Modbus network.
|
||||
*******************************************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Assign parameter description table for Modbus controller interface.
|
||||
*
|
||||
* @param[in] descriptor pointer to parameter description table
|
||||
* @param num_elements number of elements in the table
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - set descriptor successfully
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument in function call
|
||||
*/
|
||||
esp_err_t mbc_master_set_descriptor(const mb_parameter_descriptor_t* descriptor, const uint16_t num_elements);
|
||||
|
||||
/**
|
||||
* @brief Send data request as defined in parameter request, waits response
|
||||
* from slave and returns status of command execution. This function provides standard way
|
||||
* for read/write access to Modbus devices in the network.
|
||||
*
|
||||
* @param[in] request pointer to request structure of type mb_param_request_t
|
||||
* @param[in] data_ptr pointer to data buffer to send or received data (dependent of command field in request)
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - request was successful
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function
|
||||
* - esp_err_t ESP_ERR_INVALID_RESPONSE - an invalid response from slave
|
||||
* - esp_err_t ESP_ERR_TIMEOUT - operation timeout or no response from slave
|
||||
* - esp_err_t ESP_ERR_NOT_SUPPORTED - the request command is not supported by slave
|
||||
* - esp_err_t ESP_FAIL - slave returned an exception or other failure
|
||||
*/
|
||||
esp_err_t mbc_master_send_request(mb_param_request_t* request, void* data_ptr);
|
||||
|
||||
/**
|
||||
* @brief Get information about supported characteristic defined as cid. Uses parameter description table to get
|
||||
* this information. The function will check if characteristic defined as a cid parameter is supported
|
||||
* and returns its description in param_info. Returns ESP_ERR_NOT_FOUND if characteristic is not supported.
|
||||
*
|
||||
* @param[in] cid characteristic id
|
||||
* @param param_info pointer to pointer of characteristic data.
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - request was successful and buffer contains the supported characteristic name
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function
|
||||
* - esp_err_t ESP_ERR_NOT_FOUND - the characteristic (cid) not found
|
||||
* - esp_err_t ESP_FAIL - unknown error during lookup table processing
|
||||
*/
|
||||
esp_err_t mbc_master_get_cid_info(uint16_t cid, const mb_parameter_descriptor_t** param_info);
|
||||
|
||||
/**
|
||||
* @brief Read parameter from modbus slave device whose name is defined by name and has cid.
|
||||
* The additional data for request is taken from parameter description (lookup) table.
|
||||
*
|
||||
* @param[in] cid id of the characteristic for parameter
|
||||
* @param[in] name pointer into string name (key) of parameter (null terminated)
|
||||
* @param[out] value pointer to data buffer of parameter
|
||||
* @param[out] type parameter type associated with the name returned from parameter description table.
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - request was successful and value buffer contains
|
||||
* representation of actual parameter data from slave
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function or parameter descriptor
|
||||
* - esp_err_t ESP_ERR_INVALID_RESPONSE - an invalid response from slave
|
||||
* - esp_err_t ESP_ERR_INVALID_STATE - invalid state during data processing or allocation failure
|
||||
* - esp_err_t ESP_ERR_TIMEOUT - operation timed out and no response from slave
|
||||
* - esp_err_t ESP_ERR_NOT_SUPPORTED - the request command is not supported by slave
|
||||
* - esp_err_t ESP_ERR_NOT_FOUND - the parameter is not found in the parameter description table
|
||||
* - esp_err_t ESP_FAIL - slave returned an exception or other failure
|
||||
*/
|
||||
esp_err_t mbc_master_get_parameter(uint16_t cid, char* name, uint8_t* value, uint8_t *type);
|
||||
|
||||
/**
|
||||
* @brief Set characteristic's value defined as a name and cid parameter.
|
||||
* The additional data for cid parameter request is taken from master parameter lookup table.
|
||||
*
|
||||
* @param[in] cid id of the characteristic for parameter
|
||||
* @param[in] name pointer into string name (key) of parameter (null terminated)
|
||||
* @param[out] value pointer to data buffer of parameter (actual representation of json value field in binary form)
|
||||
* @param[out] type pointer to parameter type associated with the name returned from parameter lookup table.
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - request was successful and value was saved in the slave device registers
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function or parameter descriptor
|
||||
* - esp_err_t ESP_ERR_INVALID_RESPONSE - an invalid response from slave during processing of parameter
|
||||
* - esp_err_t ESP_ERR_INVALID_STATE - invalid state during data processing or allocation failure
|
||||
* - esp_err_t ESP_ERR_TIMEOUT - operation timed out and no response from slave
|
||||
* - esp_err_t ESP_ERR_NOT_SUPPORTED - the request command is not supported by slave
|
||||
* - esp_err_t ESP_FAIL - slave returned an exception or other failure
|
||||
*/
|
||||
esp_err_t mbc_master_set_parameter(uint16_t cid, char* name, uint8_t* value, uint8_t *type);
|
||||
|
||||
/**
|
||||
* @brief The helper function to set data of parameters according to its type
|
||||
*
|
||||
* @param[in] dest the destination address of the parameter
|
||||
* @param[in] src the source address of the parameter
|
||||
* @param[out] param_type type of parameter from data dictionary
|
||||
* @param[out] param_size the storage size of the characteristic (in bytes).
|
||||
* Describes the size of data to keep into data instance during mapping.
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - request was successful and value was saved in the slave device registers
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function or parameter descriptor
|
||||
* - esp_err_t ESP_ERR_NOT_SUPPORTED - the request command is not supported by slave
|
||||
*/
|
||||
esp_err_t mbc_master_set_param_data(void* dest, void* src, mb_descr_type_t param_type, size_t param_size);
|
||||
|
||||
/**
|
||||
* @brief The helper function to expose transaction info from modbus layer
|
||||
*
|
||||
* @param[in] ptinfo the pointer to transaction info structure
|
||||
*
|
||||
* @return
|
||||
* - esp_err_t ESP_OK - the transaction info is saved in the appropriate parameter structure
|
||||
* - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function or parameter descriptor
|
||||
* - esp_err_t ESP_ERR_INVALID_STATE - invalid state during data processing or allocation failure
|
||||
*/
|
||||
esp_err_t mbc_master_get_transaction_info(mb_trans_info_t *ptinfo);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // _ESP_MB_MASTER_INTERFACE_H
|
||||
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#ifndef _ESP_MB_SLAVE_INTERFACE_H
|
||||
#define _ESP_MB_SLAVE_INTERFACE_H
|
||||
|
||||
// Public interface header for slave
|
||||
#include <stdint.h> // for standard int types definition
|
||||
#include <stddef.h> // for NULL and std defines
|
||||
#include "soc/soc.h" // for BITN definitions
|
||||
#include "freertos/FreeRTOS.h" // for task creation and queues access
|
||||
#include "freertos/event_groups.h" // for event groups
|
||||
#include "esp_modbus_common.h" // for common types
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define MB_SLAVE_CHECK(a, err_code, format, ...) MB_RETURN_ON_FALSE(a, err_code, TAG, format __VA_OPT__(,) __VA_ARGS__)
|
||||
|
||||
#define MB_SLAVE_ASSERT(con) do { \
|
||||
if (!(con)) { ESP_LOGE(TAG, "assert errno:%u, errno_str: !(%s)", (unsigned)errno, strerror(errno)); assert(0 && #con); } \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* @brief Parameter access event information type
|
||||
*/
|
||||
typedef struct {
|
||||
uint32_t time_stamp; /*!< Timestamp of Modbus Event (uS)*/
|
||||
uint16_t mb_offset; /*!< Modbus register offset */
|
||||
mb_event_group_t type; /*!< Modbus event type */
|
||||
uint8_t* address; /*!< Modbus data storage address */
|
||||
size_t size; /*!< Modbus event register size (number of registers)*/
|
||||
} mb_param_info_t;
|
||||
|
||||
/**
|
||||
* @brief Parameter storage area descriptor
|
||||
*/
|
||||
typedef struct {
|
||||
uint16_t start_offset; /*!< Modbus start address for area descriptor */
|
||||
mb_param_type_t type; /*!< Type of storage area descriptor */
|
||||
void* address; /*!< Instance address for storage area descriptor */
|
||||
size_t size; /*!< Instance size for area descriptor (bytes) */
|
||||
} mb_register_area_descriptor_t;
|
||||
|
||||
/**
|
||||
* @brief Initialize Modbus Slave controller and stack for TCP port
|
||||
*
|
||||
* @param[out] handler handler(pointer) to master data structure
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_NO_MEM Parameter error
|
||||
* - ESP_ERR_NOT_SUPPORTED Port type not supported
|
||||
* - ESP_ERR_INVALID_STATE Initialization failure
|
||||
*/
|
||||
esp_err_t mbc_slave_init_tcp(void** handler);
|
||||
|
||||
/**
|
||||
* @brief Initialize Modbus Slave controller and stack for Serial port
|
||||
*
|
||||
* @param[out] handler handler(pointer) to master data structure
|
||||
* @param[in] port_type the type of port
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_NO_MEM Parameter error
|
||||
* - ESP_ERR_NOT_SUPPORTED Port type not supported
|
||||
* - ESP_ERR_INVALID_STATE Initialization failure
|
||||
*/
|
||||
esp_err_t mbc_slave_init(mb_port_type_t port_type, void** handler);
|
||||
|
||||
/**
|
||||
* @brief Initialize Modbus Slave controller interface handle
|
||||
*
|
||||
* @param[in] handler - pointer to slave interface data structure
|
||||
*/
|
||||
void mbc_slave_init_iface(void* handler);
|
||||
|
||||
/**
|
||||
* @brief Destroy Modbus controller and stack
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_INVALID_STATE Parameter error
|
||||
*/
|
||||
esp_err_t mbc_slave_destroy(void);
|
||||
|
||||
/**
|
||||
* @brief Start Modbus communication stack
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_INVALID_ARG Modbus stack start error
|
||||
*/
|
||||
esp_err_t mbc_slave_start(void);
|
||||
|
||||
/**
|
||||
* @brief Set Modbus communication parameters for the controller
|
||||
*
|
||||
* @param comm_info Communication parameters structure.
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_INVALID_ARG Incorrect parameter data
|
||||
*/
|
||||
esp_err_t mbc_slave_setup(void* comm_info);
|
||||
|
||||
/**
|
||||
* @brief Wait for specific event on parameter change.
|
||||
*
|
||||
* @param group Group event bit mask to wait for change
|
||||
*
|
||||
* @return
|
||||
* - mb_event_group_t event bits triggered
|
||||
*/
|
||||
mb_event_group_t mbc_slave_check_event(mb_event_group_t group);
|
||||
|
||||
/**
|
||||
* @brief Get parameter information
|
||||
*
|
||||
* @param[out] reg_info parameter info structure
|
||||
* @param timeout Timeout in milliseconds to read information from
|
||||
* parameter queue
|
||||
* @return
|
||||
* - ESP_OK Success
|
||||
* - ESP_ERR_TIMEOUT Can not get data from parameter queue
|
||||
* or queue overflow
|
||||
*/
|
||||
esp_err_t mbc_slave_get_param_info(mb_param_info_t* reg_info, uint32_t timeout);
|
||||
|
||||
/**
|
||||
* @brief Set Modbus area descriptor
|
||||
*
|
||||
* @param descr_data Modbus registers area descriptor structure
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: The appropriate descriptor is set
|
||||
* - ESP_ERR_INVALID_ARG: The argument is incorrect
|
||||
*/
|
||||
esp_err_t mbc_slave_set_descriptor(mb_register_area_descriptor_t descr_data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,556 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
* @brief Defines the constant values based on native compiler byte ordering.
|
||||
*/
|
||||
#define MB_BO16_0 0
|
||||
#define MB_BO16_1 1
|
||||
|
||||
#define MB_BO32_0 0
|
||||
#define MB_BO32_1 1
|
||||
#define MB_BO32_2 2
|
||||
#define MB_BO32_3 3
|
||||
|
||||
#define MB_BO64_0 0
|
||||
#define MB_BO64_1 1
|
||||
#define MB_BO64_2 2
|
||||
#define MB_BO64_3 3
|
||||
#define MB_BO64_4 4
|
||||
#define MB_BO64_5 5
|
||||
#define MB_BO64_6 6
|
||||
#define MB_BO64_7 7
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief The sized array types used for mapping of extended values
|
||||
*/
|
||||
typedef uint8_t val_16_arr[2];
|
||||
typedef uint8_t val_32_arr[4];
|
||||
typedef uint8_t val_64_arr[8];
|
||||
|
||||
/**
|
||||
* @brief Get int8_t (low byte) value represenatation from register
|
||||
*
|
||||
* @return
|
||||
* - int8_t value of converted from register value
|
||||
*/
|
||||
int8_t mb_get_int8_a(val_16_arr *pi16);
|
||||
|
||||
/**
|
||||
* @brief Set i8 value to the register value pointed by pi16
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the actual hex value of the register
|
||||
*/
|
||||
uint16_t mb_set_int8_a(val_16_arr *pi16, int8_t i8);
|
||||
|
||||
/**
|
||||
* @brief Get int8_t (high byte) value from the register value pointed by pi16
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the actual hex value of the register
|
||||
*/
|
||||
int8_t mb_get_int8_b(val_16_arr *pi16);
|
||||
|
||||
/**
|
||||
* @brief Set i8 (high byte) value from the register value pointed by pi16
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the actual hex value of the register
|
||||
*/
|
||||
uint16_t mb_set_int8_b(val_16_arr *pi16, int8_t i8);
|
||||
|
||||
/**
|
||||
* @brief Get uint8_t (low byte) value represenatation from register poined by pu16
|
||||
*
|
||||
* @return
|
||||
* - uint8_t the value of converted from register value
|
||||
*/
|
||||
uint8_t mb_get_uint8_a(val_16_arr *pu16);
|
||||
|
||||
/**
|
||||
* @brief Set u8 (low byte) value into the register value pointed by pu16
|
||||
*
|
||||
* @return
|
||||
* - uint16_t the value which represents the actual hex value of the register
|
||||
*/
|
||||
uint16_t mb_set_uint8_a(val_16_arr *pu16, uint8_t u8);
|
||||
|
||||
/**
|
||||
* @brief Get uint8_t (high byte) value from the register value pointed by pu16
|
||||
*
|
||||
* @return
|
||||
* - uint16_t the value which represents the actual hex value of the register
|
||||
*/
|
||||
uint8_t mb_get_uint8_b(val_16_arr *pu16);
|
||||
|
||||
/**
|
||||
* @brief Set u8 (high byte) value into the register value pointed by pu16
|
||||
*
|
||||
* @return
|
||||
* - uint16_t the value which represents the actual hex value of the register
|
||||
*/
|
||||
uint16_t mb_set_uint8_b(val_16_arr *pu16, uint8_t u8);
|
||||
|
||||
/**
|
||||
* @brief Get int16_t value from the register value pointed by pu16 with ab endianness
|
||||
*
|
||||
* @return
|
||||
* - int16_t the value which represents the converted value from register
|
||||
*/
|
||||
int16_t mb_get_int16_ab(val_16_arr *pi16);
|
||||
|
||||
/**
|
||||
* @brief Set i16 value to the register pointed by pi16 with ab endianness
|
||||
*
|
||||
* @return
|
||||
* - int16_t the value which represents the converted value from register
|
||||
*/
|
||||
uint16_t mb_set_int16_ab(val_16_arr *pi16, int16_t i16);
|
||||
|
||||
/**
|
||||
* @brief Get uint16_t value from the register value pointed by pu16 with ab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the converted register value
|
||||
*/
|
||||
uint16_t mb_get_uint16_ab(val_16_arr *pu16);
|
||||
|
||||
/**
|
||||
* @brief Set u16 value to the register pointed by pu16 with ab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the converted value from register
|
||||
*/
|
||||
uint16_t mb_set_uint16_ab(val_16_arr *pu16, uint16_t u16);
|
||||
|
||||
/**
|
||||
* @brief Get int16_t value from the register value pointed by pu16 with ba endianness
|
||||
*
|
||||
* @return
|
||||
* - int16_t value which represents the converted register value
|
||||
*/
|
||||
int16_t mb_get_int16_ba(val_16_arr *pi16);
|
||||
|
||||
/**
|
||||
* @brief Set i16 value to the register pointed by pi16 with ba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the converted value from register
|
||||
*/
|
||||
uint16_t mb_set_int16_ba(val_16_arr *pi16, int16_t i16);
|
||||
|
||||
/**
|
||||
* @brief Get uint16_t value from the register value pointed by pu16 with ba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the converted register value
|
||||
*/
|
||||
uint16_t mb_get_uint16_ba(val_16_arr *pu16);
|
||||
|
||||
/**
|
||||
* @brief Set u16 value to the register pointed by pu16 with ba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint16_t value which represents the converted value from register
|
||||
*/
|
||||
uint16_t mb_set_uint16_ba(val_16_arr *pu16, uint16_t u16);
|
||||
|
||||
/**
|
||||
* @brief Get int32_t value from the register value pointed by pi32 with abcd endianness
|
||||
*
|
||||
* @return
|
||||
* - int32_t value which represents the converted register value
|
||||
*/
|
||||
int32_t mb_get_int32_abcd(val_32_arr *pi32);
|
||||
|
||||
/**
|
||||
* @brief Set i32 value to the register pointed by pi32 with abcd endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_int32_abcd(val_32_arr *pi32, int32_t i32);
|
||||
|
||||
/**
|
||||
* @brief Get uint32_t value from the register value pointed by pu32 with abcd endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted register value
|
||||
*/
|
||||
uint32_t mb_get_uint32_abcd(val_32_arr *pu32);
|
||||
|
||||
/**
|
||||
* @brief Set u32 value to the register pointed by pu32 with abcd endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_uint32_abcd(val_32_arr *pu32, uint32_t u32);
|
||||
|
||||
/**
|
||||
* @brief Get int32_t value from the register value pointed by pi32 with badc endianness
|
||||
*
|
||||
* @return
|
||||
* - int32_t value which represents the converted register value
|
||||
*/
|
||||
int32_t mb_get_int32_badc(val_32_arr *pi32);
|
||||
|
||||
/**
|
||||
* @brief Set i32 value to the register pointed by pi32 with badc endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_int32_badc(val_32_arr *pi32, int32_t i32);
|
||||
|
||||
/**
|
||||
* @brief Get uint32_t value from the register value pointed by pu32 with badc endianness
|
||||
*
|
||||
* @return
|
||||
* - unt32_t value which represents the converted register value
|
||||
*/
|
||||
uint32_t mb_get_uint32_badc(val_32_arr *pu32);
|
||||
|
||||
/**
|
||||
* @brief Set u32 value to the register pointed by pu32 with badc endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_uint32_badc(val_32_arr *pu32, uint32_t u32);
|
||||
|
||||
/**
|
||||
* @brief Get int32_t value from the register value pointed by pi32 with cdab endianness
|
||||
*
|
||||
* @return
|
||||
* - int32_t value which represents the converted register value
|
||||
*/
|
||||
int32_t mb_get_int32_cdab(val_32_arr *pi32);
|
||||
|
||||
/**
|
||||
* @brief Set i32 value to the register pointed by pi32 with cdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_int32_cdab(val_32_arr *pi32, int32_t i32);
|
||||
|
||||
/**
|
||||
* @brief Get uint32_t value from the register value pointed by pu32 with cdab endianness
|
||||
*
|
||||
* @return
|
||||
* - int32_t value which represents the converted register value
|
||||
*/
|
||||
uint32_t mb_get_uint32_cdab(val_32_arr *pu32);
|
||||
|
||||
/**
|
||||
* @brief Set u32 value to the register pointed by pu32 with cdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_uint32_cdab(val_32_arr *pu32, uint32_t u32);
|
||||
|
||||
/**
|
||||
* @brief Get int32_t value from the register value pointed by pi32 with dcba endianness
|
||||
*
|
||||
* @return
|
||||
* - int32_t value which represents the converted register value
|
||||
*/
|
||||
int32_t mb_get_int32_dcba(val_32_arr *pi32);
|
||||
|
||||
/**
|
||||
* @brief Set i32 value to the register pointed by pi32 with dcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_int32_dcba(val_32_arr *pi32, int32_t i32);
|
||||
|
||||
/**
|
||||
* @brief Get uint32_t value from the register value pointed by pu32 with dcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted register value
|
||||
*/
|
||||
uint32_t mb_get_uint32_dcba(val_32_arr *pu32);
|
||||
|
||||
/**
|
||||
* @brief Set u32 value to the register pointed by pu32 with dcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_uint32_dcba(val_32_arr *pu32, uint32_t u32);
|
||||
|
||||
/**
|
||||
* @brief Get float value from the register pointed by pf with abcd endianness
|
||||
*
|
||||
* @return
|
||||
* - float value which represents the converted register value
|
||||
*/
|
||||
float mb_get_float_abcd(val_32_arr *pf);
|
||||
|
||||
/**
|
||||
* @brief Set f value to the register pointed by pf with abcd endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_float_abcd(val_32_arr *pf, float f);
|
||||
|
||||
/**
|
||||
* @brief Get float value from the register pointed by pf with badc endianness
|
||||
*
|
||||
* @return
|
||||
* - float value which represents the converted register value
|
||||
*/
|
||||
float mb_get_float_badc(val_32_arr *pf);
|
||||
|
||||
/**
|
||||
* @brief Set f value to the register pointed by pf with badc endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_float_badc(val_32_arr *pf, float f);
|
||||
|
||||
/**
|
||||
* @brief Get float value from the register pointed by pf with cdab endianness
|
||||
*
|
||||
* @return
|
||||
* - float value which represents the converted register value
|
||||
*/
|
||||
float mb_get_float_cdab(val_32_arr *pf);
|
||||
|
||||
/**
|
||||
* @brief Set f value to the register pointed by pf with cdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_float_cdab(val_32_arr *pf, float f);
|
||||
|
||||
/**
|
||||
* @brief Get float value from the register pointed by pf with dcba endianness
|
||||
*
|
||||
* @return
|
||||
* - float value which represents the converted register value
|
||||
*/
|
||||
float mb_get_float_dcba(val_32_arr *pf);
|
||||
|
||||
/**
|
||||
* @brief Set f value to the register pointed by pf with dcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint32_t value which represents the converted value from register
|
||||
*/
|
||||
uint32_t mb_set_float_dcba(val_32_arr *pf, float f);
|
||||
|
||||
/**
|
||||
* @brief Get double value from the register pointed by pd with abcdefgh endianness
|
||||
*
|
||||
* @return
|
||||
* - double value which represents the converted register value
|
||||
*/
|
||||
double mb_get_double_abcdefgh(val_64_arr *pd);
|
||||
|
||||
/**
|
||||
* @brief Set d value to the register pointed by pd with abcdefgh endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_double_abcdefgh(val_64_arr *pd, double d);
|
||||
|
||||
/**
|
||||
* @brief Get double value from the register pointed by pd with hgfedcba endianness
|
||||
*
|
||||
* @return
|
||||
* - double value which represents the converted register value
|
||||
*/
|
||||
double mb_get_double_hgfedcba(val_64_arr *pd);
|
||||
|
||||
/**
|
||||
* @brief Set d value to the register pointed by pd with hgfedcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_double_hgfedcba(val_64_arr *pd, double d);
|
||||
|
||||
/**
|
||||
* @brief Get double value from the register pointed by pd with ghefcdab endianness
|
||||
*
|
||||
* @return
|
||||
* - double value which represents the converted register value
|
||||
*/
|
||||
double mb_get_double_ghefcdab(val_64_arr *pd);
|
||||
|
||||
/**
|
||||
* @brief Set d value to the register pointed by pd with ghefcdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_double_ghefcdab(val_64_arr *pd, double d);
|
||||
|
||||
/**
|
||||
* @brief Get double value from the register pointed by pd with badcfehg endianness
|
||||
*
|
||||
* @return
|
||||
* - double value which represents the converted register value
|
||||
*/
|
||||
double mb_get_double_badcfehg(val_64_arr *pd);
|
||||
|
||||
/**
|
||||
* @brief Set d value to the register pointed by pd with badcfehg endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_double_badcfehg(val_64_arr *pd, double d);
|
||||
|
||||
/**
|
||||
* @brief Get int64_t value from the register pointed by pi64 with abcdefgh endianness
|
||||
*
|
||||
* @return
|
||||
* - int64_t value which represents the converted register value
|
||||
*/
|
||||
int64_t mb_get_int64_abcdefgh(val_64_arr *pi64);
|
||||
|
||||
/**
|
||||
* @brief Set i value to the register pointed by pi with abcdefgh endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_int64_abcdefgh(val_64_arr *pi, int64_t i);
|
||||
|
||||
/**
|
||||
* @brief Get int64_t value from the register pointed by pi64 with ghefcdab endianness
|
||||
*
|
||||
* @return
|
||||
* - int64_t value which represents the converted register value
|
||||
*/
|
||||
int64_t mb_get_int64_ghefcdab(val_64_arr *pi64);
|
||||
|
||||
/**
|
||||
* @brief Set i value to the register pointed by pi with ghefcdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_int64_ghefcdab(val_64_arr *pi, int64_t i);
|
||||
|
||||
/**
|
||||
* @brief Get int64_t value from the register pointed by pi64 with hgfedcba endianness
|
||||
*
|
||||
* @return
|
||||
* - int64_t value which represents the converted register value
|
||||
*/
|
||||
int64_t mb_get_int64_hgfedcba(val_64_arr *pi64);
|
||||
|
||||
/**
|
||||
* @brief Set i value to the register pointed by pi with hgfedcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_int64_hgfedcba(val_64_arr *pi, int64_t i);
|
||||
|
||||
/**
|
||||
* @brief Get int64_t value from the register pointed by pi64 with badcfehg endianness
|
||||
*
|
||||
* @return
|
||||
* - int64_t value which represents the converted register value
|
||||
*/
|
||||
int64_t mb_get_int64_badcfehg(val_64_arr *pi64);
|
||||
|
||||
/**
|
||||
* @brief Set i value to the register pointed by pi with badcfehg endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_int64_badcfehg(val_64_arr *pi, int64_t i);
|
||||
|
||||
/**
|
||||
* @brief Get uint64_t value from the register pointed by pui with abcdefgh endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted register value
|
||||
*/
|
||||
uint64_t mb_get_uint64_abcdefgh(val_64_arr *pui);
|
||||
|
||||
/**
|
||||
* @brief Set ui value to the register pointed by pi with abcdefgh endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_uint64_abcdefgh(val_64_arr *pui, uint64_t ui);
|
||||
|
||||
/**
|
||||
* @brief Get uint64_t value from the register pointed by pui with hgfedcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted register value
|
||||
*/
|
||||
uint64_t mb_get_uint64_hgfedcba(val_64_arr *pui);
|
||||
|
||||
/**
|
||||
* @brief Set ui value to the register pointed by pui with hgfedcba endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_uint64_hgfedcba(val_64_arr *pui, uint64_t ui);
|
||||
|
||||
/**
|
||||
* @brief Get uint64_t value from the register pointed by pui with ghefcdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted register value
|
||||
*/
|
||||
uint64_t mb_get_uint64_ghefcdab(val_64_arr *pui);
|
||||
|
||||
/**
|
||||
* @brief Set ui value to the register pointed by pui with ghefcdab endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_uint64_ghefcdab(val_64_arr *pui, uint64_t ui);
|
||||
|
||||
/**
|
||||
* @brief Get uint64_t value from the register pointed by pui with badcfehg endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted register value
|
||||
*/
|
||||
uint64_t mb_get_uint64_badcfehg(val_64_arr *pui);
|
||||
|
||||
/**
|
||||
* @brief Set ui value to the register pointed by pui with badcfehg endianness
|
||||
*
|
||||
* @return
|
||||
* - uint64_t value which represents the converted value from register
|
||||
*/
|
||||
uint64_t mb_set_uint64_badcfehg(val_64_arr *pui, uint64_t ui);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,23 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
// mbcontroller.h
|
||||
// mbcontroller - common Modbus controller header file
|
||||
|
||||
#ifndef _MODBUS_CONTROLLER_COMMON
|
||||
#define _MODBUS_CONTROLLER_COMMON
|
||||
|
||||
#include <stdint.h> // for standard int types definition
|
||||
#include <stddef.h> // for NULL and std defines
|
||||
#include "string.h" // for strerror()
|
||||
#include "errno.h" // for errno
|
||||
#include "esp_err.h" // for error handling
|
||||
#include "driver/uart.h" // for uart port number defines
|
||||
#include "sdkconfig.h" // for KConfig options
|
||||
|
||||
#include "esp_modbus_master.h"
|
||||
#include "esp_modbus_slave.h"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,683 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "mb_endianness_utils.h"
|
||||
|
||||
#define INLINE inline __attribute__((always_inline))
|
||||
|
||||
static INLINE int16_t mb_get_int16_generic(int n0, int n1, val_16_arr *psrc)
|
||||
{
|
||||
val_16_arr *pv = psrc;
|
||||
union {
|
||||
val_16_arr arr;
|
||||
int16_t value;
|
||||
} bov;
|
||||
bov.arr[n0] = (*pv)[MB_BO16_0];
|
||||
bov.arr[n1] = (*pv)[MB_BO16_1];
|
||||
return (bov.value);
|
||||
}
|
||||
|
||||
static INLINE uint16_t mb_get_uint16_generic(int n0, int n1, val_16_arr *psrc)
|
||||
{
|
||||
val_16_arr *pv = psrc;
|
||||
union {
|
||||
val_16_arr arr;
|
||||
uint16_t value;
|
||||
} bov;
|
||||
bov.arr[n0] = (*pv)[MB_BO16_0];
|
||||
bov.arr[n1] = (*pv)[MB_BO16_1];
|
||||
return (bov.value);
|
||||
}
|
||||
|
||||
static INLINE uint16_t mb_set_uint16_generic(int n0, int n1, val_16_arr *pdest, uint16_t val)
|
||||
{
|
||||
val_16_arr *pv = pdest;
|
||||
union {
|
||||
val_16_arr arr;
|
||||
uint16_t value;
|
||||
} bov;
|
||||
bov.value = val;
|
||||
(*pv)[MB_BO16_0] = bov.arr[n0];
|
||||
(*pv)[MB_BO16_1] = bov.arr[n1];
|
||||
return (*((uint16_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE int16_t mb_set_int16_generic(int n0, int n1, val_16_arr *pdest, int16_t val)
|
||||
{
|
||||
val_16_arr *pv = pdest;
|
||||
union {
|
||||
val_16_arr arr;
|
||||
int16_t value;
|
||||
} bov;
|
||||
bov.value = val;
|
||||
(*pv)[MB_BO16_0] = bov.arr[n0];
|
||||
(*pv)[MB_BO16_1] = bov.arr[n1];
|
||||
return (*((uint16_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE uint32_t mb_get_uint32_generic(int n0, int n1, int n2, int n3, val_32_arr *psrc)
|
||||
{
|
||||
val_32_arr *pv = psrc;
|
||||
union {
|
||||
val_32_arr arr;
|
||||
uint32_t value;
|
||||
} bov;
|
||||
bov.arr[n0] = (*pv)[MB_BO32_0];
|
||||
bov.arr[n1] = (*pv)[MB_BO32_1];
|
||||
bov.arr[n2] = (*pv)[MB_BO32_2];
|
||||
bov.arr[n3] = (*pv)[MB_BO32_3];
|
||||
return (bov.value);
|
||||
}
|
||||
|
||||
static INLINE int32_t mb_get_int32_generic(int n0, int n1, int n2, int n3, val_32_arr *psrc)
|
||||
{
|
||||
val_32_arr *pv = psrc;
|
||||
union {
|
||||
val_32_arr arr;
|
||||
int32_t value;
|
||||
} bov;
|
||||
bov.arr[n0] = (*pv)[MB_BO32_0];
|
||||
bov.arr[n1] = (*pv)[MB_BO32_1];
|
||||
bov.arr[n2] = (*pv)[MB_BO32_2];
|
||||
bov.arr[n3] = (*pv)[MB_BO32_3];
|
||||
return (bov.value);
|
||||
}
|
||||
|
||||
static INLINE float mb_get_float_generic(int n0, int n1, int n2, int n3, val_32_arr *psrc)
|
||||
{
|
||||
val_32_arr *pv = psrc;
|
||||
union {
|
||||
val_32_arr arr;
|
||||
float value;
|
||||
} bov;
|
||||
bov.arr[n0] = (*pv)[MB_BO32_0];
|
||||
bov.arr[n1] = (*pv)[MB_BO32_1];
|
||||
bov.arr[n2] = (*pv)[MB_BO32_2];
|
||||
bov.arr[n3] = (*pv)[MB_BO32_3];
|
||||
return (bov.value);
|
||||
}
|
||||
|
||||
static INLINE uint32_t mb_set_int32_generic(int n0, int n1, int n2, int n3, val_32_arr *pdest, int32_t val)
|
||||
{
|
||||
val_32_arr *pv = pdest;
|
||||
union {
|
||||
val_32_arr arr;
|
||||
int32_t value;
|
||||
} bov;
|
||||
bov.value = val;
|
||||
(*pv)[MB_BO32_0] = bov.arr[n0];
|
||||
(*pv)[MB_BO32_1] = bov.arr[n1];
|
||||
(*pv)[MB_BO32_2] = bov.arr[n2];
|
||||
(*pv)[MB_BO32_3] = bov.arr[n3];
|
||||
return (*((uint32_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE uint32_t mb_set_uint32_generic(int n0, int n1, int n2, int n3, val_32_arr *pdest, uint32_t val)
|
||||
{
|
||||
val_32_arr *pv = pdest;
|
||||
union {
|
||||
val_32_arr arr;
|
||||
uint32_t value;
|
||||
} bov;
|
||||
bov.value = val;
|
||||
(*pv)[MB_BO32_0] = bov.arr[n0];
|
||||
(*pv)[MB_BO32_1] = bov.arr[n1];
|
||||
(*pv)[MB_BO32_2] = bov.arr[n2];
|
||||
(*pv)[MB_BO32_3] = bov.arr[n3];
|
||||
return (*((uint32_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE uint32_t mb_set_float_generic(int n0, int n1, int n2, int n3, val_32_arr *pdest, float val)
|
||||
{
|
||||
val_32_arr *pv = pdest;
|
||||
union {
|
||||
val_32_arr arr;
|
||||
float value;
|
||||
} bov;
|
||||
bov.value = val;
|
||||
(*pv)[MB_BO32_0] = bov.arr[n0];
|
||||
(*pv)[MB_BO32_1] = bov.arr[n1];
|
||||
(*pv)[MB_BO32_2] = bov.arr[n2];
|
||||
(*pv)[MB_BO32_3] = bov.arr[n3];
|
||||
return (*((uint32_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE int64_t mb_get_int64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *psrc)
|
||||
{
|
||||
val_64_arr *pv64 = psrc;
|
||||
union {
|
||||
val_64_arr arr;
|
||||
int64_t value;
|
||||
} bo64;
|
||||
bo64.arr[n0] = (*pv64)[MB_BO64_0];
|
||||
bo64.arr[n1] = (*pv64)[MB_BO64_1];
|
||||
bo64.arr[n2] = (*pv64)[MB_BO64_2];
|
||||
bo64.arr[n3] = (*pv64)[MB_BO64_3];
|
||||
bo64.arr[n4] = (*pv64)[MB_BO64_4];
|
||||
bo64.arr[n5] = (*pv64)[MB_BO64_5];
|
||||
bo64.arr[n6] = (*pv64)[MB_BO64_6];
|
||||
bo64.arr[n7] = (*pv64)[MB_BO64_7];
|
||||
return (bo64.value);
|
||||
}
|
||||
|
||||
static INLINE uint64_t mb_get_uint64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *psrc)
|
||||
{
|
||||
val_64_arr *pv64 = psrc;
|
||||
union {
|
||||
val_64_arr arr;
|
||||
uint64_t value;
|
||||
} bo64;
|
||||
bo64.arr[n0] = (*pv64)[MB_BO64_0];
|
||||
bo64.arr[n1] = (*pv64)[MB_BO64_1];
|
||||
bo64.arr[n2] = (*pv64)[MB_BO64_2];
|
||||
bo64.arr[n3] = (*pv64)[MB_BO64_3];
|
||||
bo64.arr[n4] = (*pv64)[MB_BO64_4];
|
||||
bo64.arr[n5] = (*pv64)[MB_BO64_5];
|
||||
bo64.arr[n6] = (*pv64)[MB_BO64_6];
|
||||
bo64.arr[n7] = (*pv64)[MB_BO64_7];
|
||||
return (bo64.value);
|
||||
}
|
||||
|
||||
static INLINE double mb_get_double_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *psrc)
|
||||
{
|
||||
val_64_arr *pv64 = psrc;
|
||||
union {
|
||||
val_64_arr arr;
|
||||
double value;
|
||||
} bo64;
|
||||
bo64.arr[n0] = (*pv64)[MB_BO64_0];
|
||||
bo64.arr[n1] = (*pv64)[MB_BO64_1];
|
||||
bo64.arr[n2] = (*pv64)[MB_BO64_2];
|
||||
bo64.arr[n3] = (*pv64)[MB_BO64_3];
|
||||
bo64.arr[n4] = (*pv64)[MB_BO64_4];
|
||||
bo64.arr[n5] = (*pv64)[MB_BO64_5];
|
||||
bo64.arr[n6] = (*pv64)[MB_BO64_6];
|
||||
bo64.arr[n7] = (*pv64)[MB_BO64_7];
|
||||
return (bo64.value);
|
||||
}
|
||||
|
||||
static INLINE uint64_t mb_set_int64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *pdest, int64_t val)
|
||||
{
|
||||
val_64_arr *pv = pdest;
|
||||
union {
|
||||
val_64_arr arr;
|
||||
int64_t value;
|
||||
} bo64;
|
||||
bo64.value = val;
|
||||
(*pv)[MB_BO64_0] = bo64.arr[n0];
|
||||
(*pv)[MB_BO64_1] = bo64.arr[n1];
|
||||
(*pv)[MB_BO64_2] = bo64.arr[n2];
|
||||
(*pv)[MB_BO64_3] = bo64.arr[n3];
|
||||
(*pv)[MB_BO64_4] = bo64.arr[n4];
|
||||
(*pv)[MB_BO64_5] = bo64.arr[n5];
|
||||
(*pv)[MB_BO64_6] = bo64.arr[n6];
|
||||
(*pv)[MB_BO64_7] = bo64.arr[n7];
|
||||
return (*((uint64_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE uint64_t mb_set_uint64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *pdest, uint64_t val)
|
||||
{
|
||||
val_64_arr *pv = pdest;
|
||||
union {
|
||||
val_64_arr arr;
|
||||
uint64_t value;
|
||||
} bo64;
|
||||
bo64.value = val;
|
||||
(*pv)[MB_BO64_0] = bo64.arr[n0];
|
||||
(*pv)[MB_BO64_1] = bo64.arr[n1];
|
||||
(*pv)[MB_BO64_2] = bo64.arr[n2];
|
||||
(*pv)[MB_BO64_3] = bo64.arr[n3];
|
||||
(*pv)[MB_BO64_4] = bo64.arr[n4];
|
||||
(*pv)[MB_BO64_5] = bo64.arr[n5];
|
||||
(*pv)[MB_BO64_6] = bo64.arr[n6];
|
||||
(*pv)[MB_BO64_7] = bo64.arr[n7];
|
||||
return (*((uint64_t *)pv));
|
||||
}
|
||||
|
||||
static INLINE uint64_t mb_set_double_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *pdest, double val)
|
||||
{
|
||||
val_64_arr *pv = pdest;
|
||||
union {
|
||||
val_64_arr arr;
|
||||
double value;
|
||||
} bo64;
|
||||
bo64.value = val;
|
||||
(*pv)[MB_BO64_0] = bo64.arr[n0];
|
||||
(*pv)[MB_BO64_1] = bo64.arr[n1];
|
||||
(*pv)[MB_BO64_2] = bo64.arr[n2];
|
||||
(*pv)[MB_BO64_3] = bo64.arr[n3];
|
||||
(*pv)[MB_BO64_4] = bo64.arr[n4];
|
||||
(*pv)[MB_BO64_5] = bo64.arr[n5];
|
||||
(*pv)[MB_BO64_6] = bo64.arr[n6];
|
||||
(*pv)[MB_BO64_7] = bo64.arr[n7];
|
||||
return (*((uint64_t *)pv));
|
||||
}
|
||||
|
||||
int8_t mb_get_int8_a(pi16)
|
||||
val_16_arr *pi16;
|
||||
{
|
||||
return((int8_t)(*pi16)[MB_BO16_0]);
|
||||
}
|
||||
|
||||
uint16_t mb_set_int8_a(pi16, i8)
|
||||
val_16_arr *pi16;
|
||||
int8_t i8;
|
||||
{
|
||||
(*pi16)[MB_BO16_0] = (uint8_t)i8;
|
||||
(*pi16)[MB_BO16_1] = 0;
|
||||
return (*((uint16_t *)pi16));
|
||||
}
|
||||
|
||||
int8_t mb_get_int8_b(pi16)
|
||||
val_16_arr *pi16;
|
||||
{
|
||||
return((int8_t)(*pi16)[MB_BO16_1]);
|
||||
}
|
||||
|
||||
uint16_t mb_set_int8_b(pi16, i8)
|
||||
val_16_arr *pi16;
|
||||
int8_t i8;
|
||||
{
|
||||
(*pi16)[MB_BO16_0] = 0;
|
||||
(*pi16)[MB_BO16_1] = (int8_t)i8;
|
||||
return (*((uint16_t *)pi16));
|
||||
}
|
||||
|
||||
uint8_t mb_get_uint8_a(pu16)
|
||||
val_16_arr *pu16;
|
||||
{
|
||||
return((uint8_t)(*pu16)[MB_BO16_0]);
|
||||
}
|
||||
|
||||
uint16_t mb_set_uint8_a(pu16, u8)
|
||||
val_16_arr *pu16;
|
||||
uint8_t u8;
|
||||
{
|
||||
(*pu16)[MB_BO16_0] = (uint8_t)u8;
|
||||
(*pu16)[MB_BO16_1] = 0;
|
||||
return (*((uint16_t *)pu16));
|
||||
}
|
||||
|
||||
uint8_t mb_get_uint8_b(pu16)
|
||||
val_16_arr *pu16;
|
||||
{
|
||||
return((uint8_t)(*pu16)[MB_BO16_1]);
|
||||
}
|
||||
|
||||
uint16_t mb_set_uint8_b(pu16, u8)
|
||||
val_16_arr *pu16;
|
||||
uint8_t u8;
|
||||
{
|
||||
(*pu16)[MB_BO16_0] = 0;
|
||||
(*pu16)[MB_BO16_1] = (uint8_t)u8;
|
||||
return (*((uint16_t *)pu16));
|
||||
}
|
||||
|
||||
int16_t mb_get_int16_ab(pi16)
|
||||
val_16_arr *pi16;
|
||||
{
|
||||
return mb_get_int16_generic(0, 1, pi16);
|
||||
}
|
||||
|
||||
uint16_t mb_set_int16_ab(pi16, i16)
|
||||
val_16_arr *pi16;
|
||||
int16_t i16;
|
||||
{
|
||||
return mb_set_int16_generic(0, 1, pi16, i16);
|
||||
}
|
||||
|
||||
uint16_t mb_get_uint16_ab(pu16)
|
||||
val_16_arr *pu16;
|
||||
{
|
||||
return mb_get_uint16_generic(0, 1, pu16);
|
||||
}
|
||||
|
||||
uint16_t mb_set_uint16_ab(pu16, u16)
|
||||
val_16_arr *pu16;
|
||||
uint16_t u16;
|
||||
{
|
||||
return mb_set_uint16_generic(0, 1, pu16, u16);
|
||||
}
|
||||
|
||||
int16_t mb_get_int16_ba(pi16)
|
||||
val_16_arr *pi16;
|
||||
{
|
||||
return mb_get_int16_generic(1, 0, pi16);
|
||||
}
|
||||
|
||||
uint16_t mb_set_int16_ba(pi16, i16)
|
||||
val_16_arr *pi16;
|
||||
int16_t i16;
|
||||
{
|
||||
return mb_set_int16_generic(1, 0, pi16, i16);
|
||||
}
|
||||
|
||||
uint16_t mb_get_uint16_ba(pu16)
|
||||
val_16_arr *pu16;
|
||||
{
|
||||
return mb_get_int16_generic(1, 0, pu16);
|
||||
}
|
||||
|
||||
uint16_t mb_set_uint16_ba(pu16, u16)
|
||||
val_16_arr *pu16;
|
||||
uint16_t u16;
|
||||
{
|
||||
return mb_set_int16_generic(1, 0, pu16, u16);
|
||||
}
|
||||
|
||||
int32_t mb_get_int32_abcd(pi32)
|
||||
val_32_arr *pi32;
|
||||
{
|
||||
return mb_get_int32_generic(0, 1, 2, 3, pi32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_int32_abcd(pi32, i32)
|
||||
val_32_arr *pi32;
|
||||
int32_t i32;
|
||||
{
|
||||
return mb_set_int32_generic(0, 1, 2, 3, pi32, i32);
|
||||
}
|
||||
|
||||
uint32_t mb_get_uint32_abcd(pu32)
|
||||
val_32_arr *pu32;
|
||||
{
|
||||
return mb_get_uint32_generic(0, 1, 2, 3, pu32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_uint32_abcd(pu32, u32)
|
||||
val_32_arr *pu32;
|
||||
uint32_t u32;
|
||||
{
|
||||
return mb_set_uint32_generic(0, 1, 2, 3, pu32, u32);
|
||||
}
|
||||
|
||||
int32_t mb_get_int32_badc(pi32)
|
||||
val_32_arr *pi32;
|
||||
{
|
||||
return mb_get_int32_generic(1, 0, 3, 2, pi32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_int32_badc(pi32, i32)
|
||||
val_32_arr *pi32;
|
||||
int32_t i32;
|
||||
{
|
||||
return mb_set_int32_generic(1, 0, 3, 2, pi32, i32);
|
||||
}
|
||||
|
||||
uint32_t mb_get_uint32_badc(pu32)
|
||||
val_32_arr *pu32;
|
||||
{
|
||||
return mb_get_uint32_generic(1, 0, 3, 2, pu32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_uint32_badc(pu32, u32)
|
||||
val_32_arr *pu32;
|
||||
uint32_t u32;
|
||||
{
|
||||
return mb_set_uint32_generic(1, 0, 3, 2, pu32, u32);
|
||||
}
|
||||
|
||||
int32_t mb_get_int32_cdab(pi32)
|
||||
val_32_arr *pi32;
|
||||
{
|
||||
return mb_get_int32_generic(2, 3, 0, 1, pi32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_int32_cdab(pi32, i32)
|
||||
val_32_arr *pi32;
|
||||
int32_t i32;
|
||||
{
|
||||
return mb_set_int32_generic(2, 3, 0, 1, pi32, i32);
|
||||
}
|
||||
|
||||
uint32_t mb_get_uint32_cdab(pu32)
|
||||
val_32_arr *pu32;
|
||||
{
|
||||
return mb_get_uint32_generic(2, 3, 0, 1, pu32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_uint32_cdab(pu32, u32)
|
||||
val_32_arr *pu32;
|
||||
uint32_t u32;
|
||||
{
|
||||
return mb_set_uint32_generic(2, 3, 0, 1, pu32, u32);
|
||||
}
|
||||
|
||||
int32_t mb_get_int32_dcba(pi32)
|
||||
val_32_arr *pi32;
|
||||
{
|
||||
return mb_get_int32_generic(3, 2, 1, 0, pi32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_int32_dcba(pi32, i32)
|
||||
val_32_arr *pi32;
|
||||
int32_t i32;
|
||||
{
|
||||
return mb_set_int32_generic(3, 2, 1, 0, pi32, i32);
|
||||
}
|
||||
|
||||
uint32_t mb_get_uint32_dcba(pu32)
|
||||
val_32_arr *pu32;
|
||||
{
|
||||
return mb_get_uint32_generic(3, 2, 1, 0, pu32);
|
||||
}
|
||||
|
||||
uint32_t mb_set_uint32_dcba(pu32, u32)
|
||||
val_32_arr *pu32;
|
||||
uint32_t u32;
|
||||
{
|
||||
return mb_set_uint32_generic(3, 2, 1, 0, pu32, u32);
|
||||
}
|
||||
|
||||
float mb_get_float_abcd(pf)
|
||||
val_32_arr *pf;
|
||||
{
|
||||
return mb_get_float_generic(0, 1, 2, 3, pf);
|
||||
}
|
||||
|
||||
uint32_t mb_set_float_abcd(pf, f)
|
||||
val_32_arr *pf;
|
||||
float f;
|
||||
{
|
||||
return mb_set_float_generic(0, 1, 2, 3, pf, f);
|
||||
}
|
||||
|
||||
float mb_get_float_badc(pf)
|
||||
val_32_arr *pf;
|
||||
{
|
||||
return mb_get_float_generic(1, 0, 3, 2, pf);
|
||||
}
|
||||
|
||||
uint32_t mb_set_float_badc(pf, f)
|
||||
val_32_arr *pf;
|
||||
float f;
|
||||
{
|
||||
return mb_set_float_generic(1, 0, 3, 2, pf, f);
|
||||
}
|
||||
|
||||
float mb_get_float_cdab(pf)
|
||||
val_32_arr *pf;
|
||||
{
|
||||
return mb_get_float_generic(2, 3, 0, 1, pf);
|
||||
}
|
||||
|
||||
uint32_t mb_set_float_cdab(pf, f)
|
||||
val_32_arr *pf;
|
||||
float f;
|
||||
{
|
||||
return mb_set_float_generic(2, 3, 0, 1, pf, f);
|
||||
}
|
||||
|
||||
float mb_get_float_dcba(pf)
|
||||
val_32_arr *pf;
|
||||
{
|
||||
return mb_get_float_generic(3, 2, 1, 0, pf);
|
||||
}
|
||||
|
||||
uint32_t mb_set_float_dcba(pf, f)
|
||||
val_32_arr *pf;
|
||||
float f;
|
||||
{
|
||||
return mb_set_float_generic(3, 2, 1, 0, pf, f);
|
||||
}
|
||||
|
||||
double mb_get_double_abcdefgh(pd)
|
||||
val_64_arr *pd;
|
||||
{
|
||||
return mb_get_double_generic(0, 1, 2, 3, 4, 5, 6, 7, pd);
|
||||
}
|
||||
|
||||
uint64_t mb_set_double_abcdefgh(pd, d)
|
||||
val_64_arr *pd;
|
||||
double d;
|
||||
{
|
||||
return mb_set_double_generic(0, 1, 2, 3, 4, 5, 6, 7, pd, d);
|
||||
}
|
||||
|
||||
double mb_get_double_hgfedcba(pd)
|
||||
val_64_arr *pd;
|
||||
{
|
||||
return mb_get_double_generic(7, 6, 5, 4, 3, 2, 1, 0, pd);
|
||||
}
|
||||
|
||||
uint64_t mb_set_double_hgfedcba(pd, d)
|
||||
val_64_arr *pd;
|
||||
double d;
|
||||
{
|
||||
return mb_set_double_generic(7, 6, 5, 4, 3, 2, 1, 0, pd, d);
|
||||
}
|
||||
|
||||
double mb_get_double_ghefcdab(pd)
|
||||
val_64_arr *pd;
|
||||
{
|
||||
return mb_get_double_generic(6, 7, 4, 5, 2, 3, 0, 1, pd);
|
||||
}
|
||||
|
||||
uint64_t mb_set_double_ghefcdab(pd, d)
|
||||
val_64_arr *pd;
|
||||
double d;
|
||||
{
|
||||
return mb_set_double_generic(6, 7, 4, 5, 2, 3, 0, 1, pd, d);
|
||||
}
|
||||
|
||||
double mb_get_double_badcfehg(pd)
|
||||
val_64_arr *pd;
|
||||
{
|
||||
return mb_get_double_generic(1, 0, 3, 2, 5, 4, 7, 6, pd);
|
||||
}
|
||||
|
||||
uint64_t mb_set_double_badcfehg(pd, d)
|
||||
val_64_arr *pd;
|
||||
double d;
|
||||
{
|
||||
return mb_set_double_generic(1, 0, 3, 2, 5, 4, 7, 6, pd, d);
|
||||
}
|
||||
|
||||
int64_t mb_get_int64_abcdefgh(pi64)
|
||||
val_64_arr *pi64;
|
||||
{
|
||||
return mb_get_int64_generic(0, 1, 2, 3, 4, 5, 6, 7, pi64);
|
||||
}
|
||||
|
||||
uint64_t mb_set_int64_abcdefgh(pi, i)
|
||||
val_64_arr *pi;
|
||||
int64_t i;
|
||||
{
|
||||
return mb_set_int64_generic(0, 1, 2, 3, 4, 5, 6, 7, pi, i);
|
||||
}
|
||||
|
||||
int64_t mb_get_int64_hgfedcba(pi64)
|
||||
val_64_arr *pi64;
|
||||
{
|
||||
return mb_get_int64_generic(7, 6, 5, 4, 3, 2, 1, 0, pi64);
|
||||
}
|
||||
|
||||
uint64_t mb_set_int64_hgfedcba(pi, i)
|
||||
val_64_arr *pi;
|
||||
int64_t i;
|
||||
{
|
||||
return mb_set_int64_generic(7, 6, 5, 4, 3, 2, 1, 0, pi, i);
|
||||
}
|
||||
|
||||
int64_t mb_get_int64_ghefcdab(pi64)
|
||||
val_64_arr *pi64;
|
||||
{
|
||||
return mb_get_int64_generic(6, 7, 4, 5, 2, 3, 0, 1, pi64);
|
||||
}
|
||||
|
||||
uint64_t mb_set_int64_ghefcdab(pi, i)
|
||||
val_64_arr *pi;
|
||||
int64_t i;
|
||||
{
|
||||
return mb_set_int64_generic(6, 7, 4, 5, 2, 3, 0, 1, pi, i);
|
||||
}
|
||||
|
||||
int64_t mb_get_int64_badcfehg(pi64)
|
||||
val_64_arr *pi64;
|
||||
{
|
||||
return mb_get_int64_generic(1, 0, 3, 2, 5, 4, 7, 6, pi64);
|
||||
}
|
||||
|
||||
uint64_t mb_set_int64_badcfehg(pi, i)
|
||||
val_64_arr *pi;
|
||||
int64_t i;
|
||||
{
|
||||
return mb_set_int64_generic(1, 0, 3, 2, 5, 4, 7, 6, pi, i);
|
||||
}
|
||||
|
||||
uint64_t mb_get_uint64_abcdefgh(pui)
|
||||
val_64_arr *pui;
|
||||
{
|
||||
return mb_get_uint64_generic(0, 1, 2, 3, 4, 5, 6, 7, pui);
|
||||
}
|
||||
|
||||
uint64_t mb_set_uint64_abcdefgh(pui, ui)
|
||||
val_64_arr *pui;
|
||||
uint64_t ui;
|
||||
{
|
||||
return mb_set_uint64_generic(0, 1, 2, 3, 4, 5, 6, 7, pui, ui);
|
||||
}
|
||||
|
||||
uint64_t mb_get_uint64_hgfedcba(pui)
|
||||
val_64_arr *pui;
|
||||
{
|
||||
return mb_get_uint64_generic(7, 6, 5, 4, 3, 2, 1, 0, pui);
|
||||
}
|
||||
|
||||
uint64_t mb_set_uint64_hgfedcba(pui, ui)
|
||||
val_64_arr *pui;
|
||||
uint64_t ui;
|
||||
{
|
||||
return mb_set_uint64_generic(7, 6, 5, 4, 3, 2, 1, 0, pui, ui);
|
||||
}
|
||||
|
||||
uint64_t mb_get_uint64_ghefcdab(pui)
|
||||
val_64_arr *pui;
|
||||
{
|
||||
return mb_get_uint64_generic(6, 7, 4, 5, 2, 3, 0, 1, pui);
|
||||
}
|
||||
|
||||
uint64_t mb_set_uint64_ghefcdab(pui, ui)
|
||||
val_64_arr *pui;
|
||||
uint64_t ui;
|
||||
{
|
||||
return mb_set_uint64_generic(6, 7, 4, 5, 2, 3, 0, 1, pui, ui);
|
||||
}
|
||||
|
||||
uint64_t mb_get_uint64_badcfehg(pui)
|
||||
val_64_arr *pui;
|
||||
{
|
||||
return mb_get_int64_generic(1, 0, 3, 2, 5, 4, 7, 6, pui);
|
||||
}
|
||||
|
||||
uint64_t mb_set_uint64_badcfehg(pui, ui)
|
||||
val_64_arr *pui;
|
||||
uint64_t ui;
|
||||
{
|
||||
return mb_set_uint64_generic(1, 0, 3, 2, 5, 4, 7, 6, pui, ui);
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#ifndef _MB_CONTROLLER_MASTER_H
|
||||
#define _MB_CONTROLLER_MASTER_H
|
||||
|
||||
#include <sys/queue.h> // for list
|
||||
#include "freertos/FreeRTOS.h" // for task creation and queue access
|
||||
#include "freertos/task.h" // for task api access
|
||||
#include "freertos/event_groups.h" // for event groups
|
||||
#include "driver/uart.h" // for UART types
|
||||
#include "errno.h" // for errno
|
||||
#include "esp_log.h" // for log write
|
||||
#include "string.h" // for strerror()
|
||||
#include "esp_modbus_common.h" // for common types
|
||||
#include "esp_modbus_master.h" // for public master types
|
||||
#include "esp_modbus_callbacks.h"
|
||||
#include "mb_m.h" // this is required to expose current transaction info
|
||||
|
||||
/* ----------------------- Defines ------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Request mode for parameter to use in data dictionary
|
||||
*/
|
||||
typedef enum {
|
||||
MB_PARAM_READ, /*!< Read parameter values. */
|
||||
MB_PARAM_WRITE /*!< Write parameter values. */
|
||||
} mb_param_mode_t;
|
||||
|
||||
/**
|
||||
* @brief Device communication parameters for master
|
||||
*/
|
||||
typedef struct {
|
||||
mb_mode_type_t mode; /*!< Modbus communication mode */
|
||||
uint8_t dummy; /*!< Dummy field */
|
||||
uart_port_t port; /*!< Modbus communication port (UART) number */
|
||||
uint32_t baudrate; /*!< Modbus baudrate */
|
||||
uart_parity_t parity; /*!< Modbus UART parity settings */
|
||||
} mb_master_comm_info_t;
|
||||
|
||||
#if MB_MASTER_TCP_ENABLED
|
||||
/**
|
||||
* @brief Modbus slave addr list item for the master
|
||||
*/
|
||||
typedef struct mb_slave_addr_entry_s{
|
||||
uint16_t index; /*!< Index of the slave address */
|
||||
const char* ip_address; /*!< IP address string of the slave */
|
||||
uint8_t slave_addr; /*!< Short slave address */
|
||||
void* p_data; /*!< pointer to data structure */
|
||||
LIST_ENTRY(mb_slave_addr_entry_s) entries; /*!< The slave address entry */
|
||||
} mb_slave_addr_entry_t;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Modbus controller handler structure
|
||||
*/
|
||||
typedef struct {
|
||||
mb_port_type_t port_type; /*!< Modbus port type */
|
||||
mb_communication_info_t mbm_comm; /*!< Modbus communication info */
|
||||
uint8_t* mbm_reg_buffer_ptr; /*!< Modbus data buffer pointer */
|
||||
uint16_t mbm_reg_buffer_size; /*!< Modbus data buffer size */
|
||||
TaskHandle_t mbm_task_handle; /*!< Modbus task handle */
|
||||
EventGroupHandle_t mbm_event_group; /*!< Modbus controller event group */
|
||||
const mb_parameter_descriptor_t* mbm_param_descriptor_table; /*!< Modbus controller parameter description table */
|
||||
size_t mbm_param_descriptor_size; /*!< Modbus controller parameter description table size*/
|
||||
#if MB_MASTER_TCP_ENABLED
|
||||
LIST_HEAD(mbm_slave_addr_info_, mb_slave_addr_entry_s) mbm_slave_list; /*!< Slave address information list */
|
||||
uint16_t mbm_slave_list_count;
|
||||
#endif
|
||||
} mb_master_options_t;
|
||||
|
||||
typedef esp_err_t (*iface_get_cid_info)(uint16_t, const mb_parameter_descriptor_t**); /*!< Interface get_cid_info method */
|
||||
typedef esp_err_t (*iface_get_parameter)(uint16_t, char*, uint8_t*, uint8_t*); /*!< Interface get_parameter method */
|
||||
typedef esp_err_t (*iface_send_request)(mb_param_request_t*, void*); /*!< Interface send_request method */
|
||||
typedef esp_err_t (*iface_set_descriptor)(const mb_parameter_descriptor_t*, const uint16_t); /*!< Interface set_descriptor method */
|
||||
typedef esp_err_t (*iface_set_parameter)(uint16_t, char*, uint8_t*, uint8_t*); /*!< Interface set_parameter method */
|
||||
|
||||
/**
|
||||
* @brief Modbus controller interface structure
|
||||
*/
|
||||
typedef struct {
|
||||
// Master object interface options
|
||||
mb_master_options_t opts;
|
||||
|
||||
// Public interface methods
|
||||
iface_init init; /*!< Interface method init */
|
||||
iface_destroy destroy; /*!< Interface method destroy */
|
||||
iface_setup setup; /*!< Interface method setup */
|
||||
iface_start start; /*!< Interface method start */
|
||||
iface_get_cid_info get_cid_info; /*!< Interface get_cid_info method */
|
||||
iface_get_parameter get_parameter; /*!< Interface get_parameter method */
|
||||
iface_send_request send_request; /*!< Interface send_request method */
|
||||
iface_set_descriptor set_descriptor; /*!< Interface set_descriptor method */
|
||||
iface_set_parameter set_parameter; /*!< Interface set_parameter method */
|
||||
// Modbus register calback function pointers
|
||||
reg_discrete_cb master_reg_cb_discrete; /*!< Stack callback discrete rw method */
|
||||
reg_input_cb master_reg_cb_input; /*!< Stack callback input rw method */
|
||||
reg_holding_cb master_reg_cb_holding; /*!< Stack callback holding rw method */
|
||||
reg_coils_cb master_reg_cb_coils; /*!< Stack callback coils rw method */
|
||||
} mb_master_interface_t;
|
||||
|
||||
#endif //_MB_CONTROLLER_MASTER_H
|
||||
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#ifndef _MB_CONTROLLER_SLAVE_H
|
||||
#define _MB_CONTROLLER_SLAVE_H
|
||||
|
||||
#include "driver/uart.h" // for uart defines
|
||||
#include "errno.h" // for errno
|
||||
#include "sys/queue.h" // for list
|
||||
#include "esp_log.h" // for log write
|
||||
#include "string.h" // for strerror()
|
||||
|
||||
#include "esp_modbus_slave.h" // for public type defines
|
||||
#include "esp_modbus_callbacks.h" // for callback functions
|
||||
|
||||
/* ----------------------- Defines ------------------------------------------*/
|
||||
#define MB_INST_MIN_SIZE (2) // The minimal size of Modbus registers area in bytes
|
||||
#define MB_INST_MAX_SIZE (65535 * 2) // The maximum size of Modbus area in bytes
|
||||
|
||||
#define MB_CONTROLLER_NOTIFY_QUEUE_SIZE (CONFIG_FMB_CONTROLLER_NOTIFY_QUEUE_SIZE) // Number of messages in parameter notification queue
|
||||
#define MB_CONTROLLER_NOTIFY_TIMEOUT (pdMS_TO_TICKS(CONFIG_FMB_CONTROLLER_NOTIFY_TIMEOUT)) // notification timeout
|
||||
|
||||
/**
|
||||
* @brief Device communication parameters for master
|
||||
*/
|
||||
typedef struct {
|
||||
mb_mode_type_t mode; /*!< Modbus communication mode */
|
||||
uint8_t slave_addr; /*!< Slave address field */
|
||||
uart_port_t port; /*!< Modbus communication port (UART) number */
|
||||
uint32_t baudrate; /*!< Modbus baudrate */
|
||||
uart_parity_t parity; /*!< Modbus UART parity settings */
|
||||
} mb_slave_comm_info_t;
|
||||
|
||||
/**
|
||||
* @brief Modbus area descriptor list item
|
||||
*/
|
||||
typedef struct mb_descr_entry_s{
|
||||
uint16_t start_offset; /*!< Modbus start address for area descriptor */
|
||||
mb_param_type_t type; /*!< Type of storage area descriptor */
|
||||
void* p_data; /*!< Instance address for storage area descriptor */
|
||||
size_t size; /*!< Instance size for area descriptor (bytes) */
|
||||
LIST_ENTRY(mb_descr_entry_s) entries; /*!< The Modbus area descriptor entry */
|
||||
} mb_descr_entry_t;
|
||||
|
||||
/**
|
||||
* @brief Modbus controller handler structure
|
||||
*/
|
||||
typedef struct {
|
||||
mb_port_type_t port_type; /*!< port type */
|
||||
mb_communication_info_t mbs_comm; /*!< communication info */
|
||||
TaskHandle_t mbs_task_handle; /*!< task handle */
|
||||
EventGroupHandle_t mbs_event_group; /*!< controller event group */
|
||||
QueueHandle_t mbs_notification_queue_handle; /*!< controller notification queue */
|
||||
LIST_HEAD(mbs_area_descriptors_, mb_descr_entry_s) mbs_area_descriptors[MB_PARAM_COUNT]; /*!< register area descriptors */
|
||||
} mb_slave_options_t;
|
||||
|
||||
typedef mb_event_group_t (*iface_check_event)(mb_event_group_t); /*!< Interface method check_event */
|
||||
typedef esp_err_t (*iface_get_param_info)(mb_param_info_t*, uint32_t); /*!< Interface method get_param_info */
|
||||
typedef esp_err_t (*iface_set_descriptor)(mb_register_area_descriptor_t); /*!< Interface method set_descriptor */
|
||||
|
||||
/**
|
||||
* @brief Request mode for parameter to use in data dictionary
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
mb_slave_options_t opts; /*!< Modbus slave options */
|
||||
|
||||
// Functional pointers to internal static functions of the implementation (public interface methods)
|
||||
iface_init init; /*!< Interface method init */
|
||||
iface_destroy destroy; /*!< Interface method destroy */
|
||||
iface_setup setup; /*!< Interface method setup */
|
||||
iface_start start; /*!< Interface method start */
|
||||
iface_check_event check_event; /*!< Interface method check_event */
|
||||
iface_get_param_info get_param_info; /*!< Interface method get_param_info */
|
||||
iface_set_descriptor set_descriptor; /*!< Interface method set_descriptor */
|
||||
|
||||
// Modbus register calback function pointers
|
||||
reg_discrete_cb slave_reg_cb_discrete; /*!< Stack callback discrete rw method */
|
||||
reg_input_cb slave_reg_cb_input; /*!< Stack callback input rw method */
|
||||
reg_holding_cb slave_reg_cb_holding; /*!< Stack callback holding rw method */
|
||||
reg_coils_cb slave_reg_cb_coils; /*!< Stack callback coils rw method */
|
||||
} mb_slave_interface_t;
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user