Библиотека modbus c++ modbuspp с X20PS9400a B&R ⇐ C++

[Anonymous]

Я не могу настроить цифровой выход/катушку на X20PS9400a B&R с помощью библиотеки modbuspp
Я безуспешно пытался запустить следующий пример для настройки цифрового выхода на X20PS9400a B&R:< /p>

Код: Выделить всё

#include 
#include "modbus.h"

int main()
{
// create a modbus object
modbus mb = modbus("192.168.100.1", 502);

for (int i = 0; i> 8u);
to_send[9] = (uint8_t)(address & 0x00FFu);
}

/**
* Write Request Builder and Sender
* @param address   Reference Address
* @param amount    Amount of data to be Written
* @param func      Modbus Functional Code
* @param value     Data to Be Written
*/
inline int modbus::modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value)
{
int status = 0;
uint8_t *to_send;
if (func == WRITE_COIL || func == WRITE_REG)
{
to_send = new uint8_t[12];
modbus_build_request(to_send, address, func);
to_send[5] = 6;
to_send[10] = (uint8_t)(value[0] >> 8u);
to_send[11] = (uint8_t)(value[0] & 0x00FFu);
status = modbus_send(to_send, 12);
}
else if (func == WRITE_REGS)
{
to_send = new uint8_t[13 + 2 * amount];
modbus_build_request(to_send, address, func);
to_send[5] = (uint8_t)(7 + 2 * amount);
to_send[10] = (uint8_t)(amount >> 8u);
to_send[11] = (uint8_t)(amount & 0x00FFu);
to_send[12] = (uint8_t)(2 * amount);
for (int i = 0; i < amount; i++)
{
to_send[13 + 2 * i] = (uint8_t)(value[i] >> 8u);
to_send[14 + 2 * i] = (uint8_t)(value[i] & 0x00FFu);
}
status = modbus_send(to_send, 13 + 2 * amount);
}
else if (func == WRITE_COILS)
{
to_send = new uint8_t[14 + (amount - 1) / 8];
modbus_build_request(to_send, address, func);
to_send[5] = (uint8_t)(7 + (amount + 7) / 8);
to_send[10] = (uint8_t)(amount >> 8u);
to_send[11] = (uint8_t)(amount & 0x00FFu);
to_send[12] = (uint8_t)((amount + 7) / 8);
for (int i = 0; i < (amount + 7) / 8; i++)
to_send[13 + i] = 0; // init needed before summing!
for (int i = 0; i < amount; i++)
{
to_send[13 + i / 8] += (uint8_t)(value[i] > 8u);
to_send[11] = (uint8_t)(amount & 0x00FFu);
return modbus_send(to_send, 12);
}

/**
* Read Holding Registers
* MODBUS FUNCTION 0x03
* @param address    Reference Address
* @param amount     Amount of Registers to Read
* @param buffer     Buffer to Store Data Read from Registers
*/
inline int modbus::modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
{
if (_connected)
{
modbus_read(address, amount, READ_REGS);
uint8_t to_rec[MAX_MSG_LENGTH];
ssize_t k = modbus_receive(to_rec);
if (k == -1)
{
set_bad_con();
return BAD_CON;
}
modbuserror_handle(to_rec, READ_REGS);
if (err)
return err_no;
for (auto i = 0; i < amount; i++)
{
buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) > (i % 8u)) & 1u);
}
return 0;
}
else
{
set_bad_con();
return BAD_CON;
}
}

/**
* Read Input Bits(Discrete Data)
* MODBUS FUNCITON 0x02
* @param address   Reference Address
* @param amount    Amount of Bits to Read
* @param buffer    Buffer to store Data Read from Input Bits
*/
inline int modbus::modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer)
{
if (_connected)
{
if (amount > 2040)
{
set_bad_input();
return EX_BAD_DATA;
}
modbus_read(address, amount, READ_INPUT_BITS);
uint8_t to_rec[MAX_MSG_LENGTH];
ssize_t k = modbus_receive(to_rec);
if (k == -1)
{
set_bad_con();
return BAD_CON;
}
if (err)
return err_no;
for (auto i = 0; i < amount; i++)
{
buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) &  1u);
}
modbuserror_handle(to_rec, READ_INPUT_BITS);
return 0;
}
else
{
return BAD_CON;
}
}

/**
* Write Single Coils
* MODBUS FUNCTION 0x05
* @param address    Reference Address
* @param to_write   Value to be Written to Coil
*/
inline int modbus::modbus_write_coil(uint16_t address, const bool &to_write)
{
if (_connected)
{
int value = to_write * 0xFF00;
modbus_write(address, 1, WRITE_COIL, (uint16_t *)&value);
uint8_t to_rec[MAX_MSG_LENGTH];
ssize_t k = modbus_receive(to_rec);
if (k == -1)
{
set_bad_con();
return BAD_CON;
}
modbuserror_handle(to_rec, WRITE_COIL);
if (err)
return err_no;
return 0;
}
else
{
set_bad_con();
return BAD_CON;
}
}

/**
* Write Single Register
* FUCTION 0x06
* @param address   Reference Address
* @param value     Value to Be Written to Register
*/
inline int modbus::modbus_write_register(uint16_t address, const uint16_t &value)
{
if (_connected)
{
modbus_write(address, 1, WRITE_REG, &value);
uint8_t to_rec[MAX_MSG_LENGTH];
ssize_t k = modbus_receive(to_rec);
if (k == -1)
{
set_bad_con();
return BAD_CON;
}
modbuserror_handle(to_rec, WRITE_COIL);
if (err)
return err_no;
return 0;
}
else
{
set_bad_con();
return BAD_CON;
}
}

/**
* Write Multiple Coils
* MODBUS FUNCTION 0x0F
* @param address  Reference Address
* @param amount   Amount of Coils to Write
* @param value    Values to Be Written to Coils
*/
inline int modbus::modbus_write_coils(uint16_t address, uint16_t amount, const bool *value)
{
if (_connected)
{
uint16_t *temp = new uint16_t[amount];
for (int i = 0; i < amount;  i++)
{
temp[i] = (uint16_t)value[i];
}
modbus_write(address, amount, WRITE_COILS, temp);
delete[] temp;
uint8_t to_rec[MAX_MSG_LENGTH];
ssize_t k = modbus_receive(to_rec);
if (k == -1)
{
set_bad_con();
return BAD_CON;
}
modbuserror_handle(to_rec, WRITE_COILS);
if (err)
return err_no;
return 0;
}
else
{
set_bad_con();
return BAD_CON;
}
}

/**
* Write Multiple Registers
* MODBUS FUNCION 0x10
* @param address Reference Address
* @param amount  Amount of Value to Write
* @param value   Values to Be Written to the Registers
*/
inline int modbus::modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value)
{
if (_connected)
{
modbus_write(address, amount, WRITE_REGS, value);
uint8_t to_rec[MAX_MSG_LENGTH];
ssize_t k = modbus_receive(to_rec);
if (k == -1)
{
set_bad_con();
return BAD_CON;
}
modbuserror_handle(to_rec, WRITE_REGS);
if (err)
return err_no;
return 0;
}
else
{
set_bad_con();
return BAD_CON;
}
}

/**
* Data Sender
* @param to_send Request to Be Sent to Server
* @param length  Length of the Request
* @return        Size of the request
*/
inline ssize_t modbus::modbus_send(uint8_t *to_send, size_t length)
{
_msg_id++;
return send(_socket, (const char *)to_send, (size_t)length, 0);
}

/**
* Data Receiver
* @param buffer Buffer to Store the Data Retrieved
* @return       Size of Incoming Data
*/
inline ssize_t modbus::modbus_receive(uint8_t *buffer) const
{
return recv(_socket, (char *)buffer, MAX_MSG_LENGTH, 0);
}

inline void modbus::set_bad_con()
{
err = true;
error_msg = "BAD CONNECTION";
}

inline void modbus::set_bad_input()
{
err = true;
error_msg = "BAD FUNCTION INPUT";
}

/**
* Error Code Handler
* @param msg   Message Received from the Server
* @param func  Modbus Functional Code
*/
inline void modbus::modbuserror_handle(const uint8_t *msg, int func)
{
err = false;
error_msg = "NO ERR";
if (msg[7] == func + 0x80)
{
err = true;
switch (msg[8])
{
case EX_ILLEGAL_FUNCTION:
error_msg = "1 Illegal Function";
break;
case EX_ILLEGAL_ADDRESS:
error_msg = "2 Illegal Address";
break;
case EX_ILLEGAL_VALUE:
error_msg = "3 Illegal Value";
break;
case EX_SERVER_FAILURE:
error_msg = "4 Server Failure";
break;
case EX_ACKNOWLEDGE:
error_msg = "5 Acknowledge";
break;
case EX_SERVER_BUSY:
error_msg = "6 Server Busy";
break;
case EX_NEGATIVE_ACK:
error_msg = "7 Negative Acknowledge";
break;
case EX_MEM_PARITY_PROB:
error_msg = "8 Memory Parity Problem";
break;
case EX_GATEWAY_PROBLEMP:
error_msg = "10 Gateway Path Unavailable";
break;
case EX_GATEWAY_PROBLEMF:
error_msg = "11 Gateway Target Device Failed to Respond";
break;
default:
error_msg = "UNK";
break;
}
}
}

#endif //MODBUSPP_MODBUS_H

Я компилирую все на windows 10 следующим образом:

Код: Выделить всё

cl /I. /Ot /EHsc /nologo /Femain.exe main.cpp

Буду очень признателен, если кто-то сможет мне помочь.

Подробнее здесь: https://stackoverflow.com/questions/779 ... ps9400a-br