729 lines
28 KiB
C++
729 lines
28 KiB
C++
|
#include "iobox_api.h"
|
||
|
|
namespace ANSCENTER {
|
||
|
|
iobox_api::iobox_api(std::string ipmcast, int port_mcast)
|
||
|
|
{
|
||
|
|
this->ip_mcast = ipmcast;
|
||
|
|
this->port_mcast = port_mcast;
|
||
|
|
WSADATA wsaData;
|
||
|
|
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
|
||
|
|
std::cerr << "WSAStartup failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
iobox_api::~iobox_api()
|
||
|
|
{
|
||
|
|
WSACleanup();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool isStringExistInVectorString(const std::vector<std::string>& vec, const std::string& str) {
|
||
|
|
for (const auto& item : vec) {
|
||
|
|
if (item == str) {
|
||
|
|
std::cout << "Found duplicate: " << str << std::endl;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
// return std::find(vec.begin(), vec.end(), str) != vec.end();
|
||
|
|
}
|
||
|
|
|
||
|
|
void printBufferAsHex(const char* buffer, size_t length) {
|
||
|
|
for (size_t i = 0; i < length; ++i) {
|
||
|
|
printf("%02X ", static_cast<unsigned char>(buffer[i]));
|
||
|
|
if ((i + 1) % 16 == 0) {
|
||
|
|
printf("\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
printf("\n");
|
||
|
|
}
|
||
|
|
void printStringAsHex(const std::string& str) {
|
||
|
|
for (size_t i = 0; i < str.size(); ++i) {
|
||
|
|
printf("%02X ", static_cast<unsigned char>(str[i]));
|
||
|
|
if ((i + 1) % 16 == 0) {
|
||
|
|
printf("\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
printf("\n");
|
||
|
|
}
|
||
|
|
iobox_info_t parseIoboxResponse(const std::string& response) {
|
||
|
|
iobox_info_t info;
|
||
|
|
size_t ipPos = response.find("IOBOX_RESPONSE:");
|
||
|
|
size_t modbusPos = response.find("modbus_address:");
|
||
|
|
|
||
|
|
if (ipPos != std::string::npos && modbusPos != std::string::npos) {
|
||
|
|
ipPos += strlen("IOBOX_RESPONSE:");
|
||
|
|
modbusPos += strlen("modbus_address:");
|
||
|
|
|
||
|
|
size_t ipEnd = response.find(',', ipPos);
|
||
|
|
if (ipEnd != std::string::npos) {
|
||
|
|
info.ip_address = response.substr(ipPos, ipEnd - ipPos);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string modbusStr = response.substr(modbusPos);
|
||
|
|
info.modbus_address = std::stoi(modbusStr);
|
||
|
|
}
|
||
|
|
|
||
|
|
return info;
|
||
|
|
}
|
||
|
|
void show_info_iobox(iobox_info_t iobox_info) {
|
||
|
|
std::cout << " IP Address: " << iobox_info.ip_address << std::endl;
|
||
|
|
std::cout << " Modbus Address: " << (int)iobox_info.modbus_address << std::endl;
|
||
|
|
}
|
||
|
|
void iobox_api::show_profile_iobox(std::string ip) {
|
||
|
|
iobox_profile_t* profile = findProfileByIp(ip);
|
||
|
|
if (profile == nullptr) {
|
||
|
|
std::cerr << "IP address not found: " << ip << std::endl;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
show_profile_iobox(*profile);
|
||
|
|
}
|
||
|
|
void iobox_api::show_profile_iobox(iobox_profile_t profile) {
|
||
|
|
// std::cout << "Profile ioboxs: " << this->iobox_profiles.size() << std::endl;
|
||
|
|
// for (const iobox_profile_t& profile : this->iobox_profiles) {
|
||
|
|
// std::cout << "* Index: " << &profile - &this->iobox_profiles[0] << std::endl;
|
||
|
|
show_info_iobox(profile.iobox_info);
|
||
|
|
std::cout << " Counting get: " << profile.counting_get << std::endl;
|
||
|
|
std::cout << " Is connected: " << profile.is_connected << std::endl;
|
||
|
|
if (profile.counting_get)
|
||
|
|
{
|
||
|
|
std::cout << " Modbus address: " << profile.iobox_data.modbus_address << std::endl;
|
||
|
|
std::cout << " Serial number: " << reinterpret_cast<const char*>(profile.iobox_data.serial_number) << std::endl;
|
||
|
|
uint8_t hw_version = (profile.iobox_data.version >> 8) & 0xFF;
|
||
|
|
uint8_t fw_version = profile.iobox_data.version & 0xFF;
|
||
|
|
std::cout << " HW Version: " << static_cast<int>(hw_version) << std::endl;
|
||
|
|
std::cout << " FW Version: " << static_cast<int>(fw_version) << std::endl;
|
||
|
|
std::cout << " Channel DO: ";
|
||
|
|
std::cout << profile.iobox_data.channel_DO[0] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_DO[1] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_DO[2] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_DO[3] << std::endl;
|
||
|
|
std::cout << " Channel DI: ";
|
||
|
|
std::cout << profile.iobox_data.channel_DI[0] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_DI[1] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_DI[2] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_DI[3] << std::endl;
|
||
|
|
std::cout << " Channel AI: ";
|
||
|
|
std::cout << profile.iobox_data.channel_AI[0] << " ";
|
||
|
|
std::cout << profile.iobox_data.channel_AI[1] << std::endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
// }
|
||
|
|
}
|
||
|
|
void iobox_api::show_profile_ioboxs() {
|
||
|
|
if (this->iobox_profiles.size() == 0) {
|
||
|
|
std::cout << "No iobox profiles" << std::endl;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (const auto& profile : this->iobox_profiles) {
|
||
|
|
std::cout << "* Index: " << &profile - &this->iobox_profiles[0] << std::endl;
|
||
|
|
show_profile_iobox(profile);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//void iobox_api::save_info_iobox(iobox_info_t iobox_info) {
|
||
|
|
// iobox_profile_t profile = {
|
||
|
|
// .counting_get = 0,
|
||
|
|
// .is_connected = false,
|
||
|
|
// .sock_tcp = INVALID_SOCKET,
|
||
|
|
// };
|
||
|
|
// profile.iobox_info = iobox_info;
|
||
|
|
// this->iobox_profiles.push_back(profile);
|
||
|
|
//}
|
||
|
|
void iobox_api::save_info_iobox(iobox_info_t iobox_info) {
|
||
|
|
iobox_profile_t profile;
|
||
|
|
profile.counting_get = 0;
|
||
|
|
profile.is_connected = false;
|
||
|
|
profile.sock_tcp = INVALID_SOCKET;
|
||
|
|
profile.iobox_info = iobox_info;
|
||
|
|
|
||
|
|
this->iobox_profiles.push_back(profile);
|
||
|
|
}
|
||
|
|
bool iobox_api::sendTcpMessage(const std::string& ip, const char* buffer, size_t length) {
|
||
|
|
for (auto& profile : this->iobox_profiles) {
|
||
|
|
if (profile.iobox_info.ip_address == ip && profile.is_connected && profile.sock_tcp != INVALID_SOCKET) {
|
||
|
|
int result = send(profile.sock_tcp, buffer, length, 0);
|
||
|
|
if (result == SOCKET_ERROR) {
|
||
|
|
std::cerr << "send failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
std::cout << "Sent " << length << " bytes message to " << ip << std::endl;
|
||
|
|
printBufferAsHex(buffer, length);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
std::cerr << "IP address not found or not connected: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool iobox_api::receiveTcpMessage(const std::string& ip, char* buffer, size_t& length) {
|
||
|
|
for (auto& profile : this->iobox_profiles) {
|
||
|
|
if (profile.iobox_info.ip_address == ip && profile.is_connected && profile.sock_tcp != INVALID_SOCKET) {
|
||
|
|
setSocketTimeout(profile.sock_tcp, 3000);
|
||
|
|
int recvLen = recv(profile.sock_tcp, buffer, length, 0);
|
||
|
|
if (recvLen > 0) {
|
||
|
|
length = recvLen;
|
||
|
|
std::cout << "Received message: " << length << " bytes" << std::endl;
|
||
|
|
printBufferAsHex(buffer, recvLen);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
std::cerr << "recv failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
std::cerr << "IP address not found or not connected: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void iobox_api::sendMulticastMessage(const std::string& message) {
|
||
|
|
SOCKET sock = INVALID_SOCKET;
|
||
|
|
struct sockaddr_in multicastAddr;
|
||
|
|
|
||
|
|
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
||
|
|
if (sock == INVALID_SOCKET) {
|
||
|
|
std::cerr << "socket failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
WSACleanup();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
memset(&multicastAddr, 0, sizeof(multicastAddr));
|
||
|
|
multicastAddr.sin_family = AF_INET;
|
||
|
|
multicastAddr.sin_addr.s_addr = inet_addr(this->ip_mcast.c_str());
|
||
|
|
multicastAddr.sin_port = htons(this->port_mcast);
|
||
|
|
|
||
|
|
if (sendto(sock, message.c_str(), message.length(), 0, (struct sockaddr*)&multicastAddr, sizeof(multicastAddr)) == SOCKET_ERROR) {
|
||
|
|
std::cerr << "sendto failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
std::cout << "Sent message: " << message << std::endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
closesocket(sock);
|
||
|
|
}
|
||
|
|
void iobox_api::setSocketTimeout(SOCKET sock, int timeout) {
|
||
|
|
struct timeval tv;
|
||
|
|
tv.tv_sec = timeout;
|
||
|
|
tv.tv_usec = 0;
|
||
|
|
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)) < 0) {
|
||
|
|
std::cerr << "setsockopt failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
std::vector<std::string> iobox_api::scanNetworkDevicesMulticast(int timeout) {
|
||
|
|
std::vector<std::string> devices;
|
||
|
|
|
||
|
|
for (const auto& item : this->iobox_profiles) {
|
||
|
|
if (item.is_connected || item.sock_tcp != INVALID_SOCKET) {
|
||
|
|
std::cout << "Please close connection to " << item.iobox_info.ip_address << "befor new scan" << std::endl;
|
||
|
|
return devices;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//remove all elements from iobox_profiles before and we start with new scan
|
||
|
|
this->iobox_profiles.clear();
|
||
|
|
|
||
|
|
// WSADATA wsaData;
|
||
|
|
SOCKET sock = INVALID_SOCKET;
|
||
|
|
struct sockaddr_in multicastAddr;
|
||
|
|
struct ip_mreq multicastRequest;
|
||
|
|
char recvBuf[1024];
|
||
|
|
struct sockaddr_in recvAddr;
|
||
|
|
int recvAddrLen = sizeof(recvAddr);
|
||
|
|
std::string message = "IOBOX_DISCOVERY";
|
||
|
|
|
||
|
|
// if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
|
||
|
|
// std::cerr << "WSAStartup failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
// return devices;
|
||
|
|
// }
|
||
|
|
|
||
|
|
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
||
|
|
if (sock == INVALID_SOCKET) {
|
||
|
|
std::cerr << "socket failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
// WSACleanup();
|
||
|
|
return devices;
|
||
|
|
}
|
||
|
|
|
||
|
|
memset(&multicastAddr, 0, sizeof(multicastAddr));
|
||
|
|
multicastAddr.sin_family = AF_INET;
|
||
|
|
multicastAddr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||
|
|
multicastAddr.sin_port = htons(this->port_mcast);
|
||
|
|
if (bind(sock, (struct sockaddr*)&multicastAddr, sizeof(multicastAddr)) == SOCKET_ERROR) {
|
||
|
|
std::cerr << "bind failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
closesocket(sock);
|
||
|
|
// WSACleanup();
|
||
|
|
return devices;
|
||
|
|
}
|
||
|
|
multicastRequest.imr_multiaddr.s_addr = inet_addr(this->ip_mcast.c_str());
|
||
|
|
multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
|
||
|
|
|
||
|
|
#ifndef TEST_FIX_IP
|
||
|
|
if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&multicastRequest, sizeof(multicastRequest)) < 0) {
|
||
|
|
std::cerr << "setsockopt failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
closesocket(sock);
|
||
|
|
// WSACleanup();
|
||
|
|
return devices;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
setSocketTimeout(sock, 3000);
|
||
|
|
|
||
|
|
auto start = std::chrono::steady_clock::now();
|
||
|
|
// sendMulticastMessage(message);
|
||
|
|
while (std::chrono::steady_clock::now() - start < std::chrono::seconds(timeout)) {
|
||
|
|
int recvLen = recvfrom(sock, recvBuf, sizeof(recvBuf) - 1, 0, (struct sockaddr*)&recvAddr, &recvAddrLen);
|
||
|
|
if (recvLen > 0) {
|
||
|
|
recvBuf[recvLen] = '\0';
|
||
|
|
std::string message_rsp(recvBuf);
|
||
|
|
std::string senderIp = inet_ntoa(recvAddr.sin_addr);
|
||
|
|
std::cout << "Received message: \"" << message_rsp << "\" from " << senderIp << std::endl;
|
||
|
|
|
||
|
|
iobox_info_t info = parseIoboxResponse(message_rsp);
|
||
|
|
if (info.ip_address == senderIp && info.ip_address != "" && !isStringExistInVectorString(devices, senderIp)) {
|
||
|
|
std::string deviceInfo;
|
||
|
|
std::string deviceAlias = "ANSDAQ1";
|
||
|
|
std::string deviceSN = "SN123456";
|
||
|
|
std::string deviceModel = "ANSIOBOX";
|
||
|
|
deviceInfo = deviceAlias + "-"
|
||
|
|
+ deviceModel + "-"
|
||
|
|
+ deviceSN + "-"+ senderIp;
|
||
|
|
devices.push_back(deviceInfo);
|
||
|
|
save_info_iobox(info);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
//std::cerr << "recvfrom failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
sendMulticastMessage(message);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#ifndef TEST_FIX_IP
|
||
|
|
setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char*)&multicastRequest, sizeof(multicastRequest));
|
||
|
|
#endif
|
||
|
|
closesocket(sock);
|
||
|
|
// WSACleanup();
|
||
|
|
return devices;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool iobox_api::connectToIobox(const std::string& ip, int port, const std::string& username, const std::string& password) {
|
||
|
|
// check ip is already in iobox_profiles
|
||
|
|
bool is_exist = false;
|
||
|
|
iobox_profile_t* item = nullptr;
|
||
|
|
|
||
|
|
for (auto& profile : this->iobox_profiles) {
|
||
|
|
if (profile.iobox_info.ip_address == ip) {
|
||
|
|
is_exist = true;
|
||
|
|
item = &profile;
|
||
|
|
if (item->is_connected) {
|
||
|
|
std::cout << "Ip is already connected: " << ip << std::endl;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (is_exist == false) {
|
||
|
|
std::cout << "Ip is not exist in list scan" << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// WSADATA wsaData;
|
||
|
|
SOCKET sock = INVALID_SOCKET;
|
||
|
|
struct sockaddr_in serverAddr;
|
||
|
|
//char recvBuf[1024];
|
||
|
|
int recvLen = 0;
|
||
|
|
struct timeval tv;
|
||
|
|
tv.tv_sec = 3;
|
||
|
|
tv.tv_usec = 0;
|
||
|
|
// Initialize Winsock
|
||
|
|
// int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
|
||
|
|
// if (result != 0) {
|
||
|
|
// std::cerr << "WSAStartup failed: " << result << std::endl;
|
||
|
|
// return false;
|
||
|
|
// }
|
||
|
|
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||
|
|
if (sock == INVALID_SOCKET) {
|
||
|
|
std::cerr << "socket failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
// WSACleanup();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
serverAddr.sin_family = AF_INET;
|
||
|
|
serverAddr.sin_addr.s_addr = inet_addr(ip.c_str());
|
||
|
|
serverAddr.sin_port = htons(port);
|
||
|
|
|
||
|
|
if (connect(sock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
|
||
|
|
std::cerr << "connect failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
closesocket(sock);
|
||
|
|
// WSACleanup();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
|
||
|
|
// recvLen = recv(sock, recvBuf, sizeof(recvBuf) - 1, 0);
|
||
|
|
// if (recvLen > 0) {
|
||
|
|
// recvBuf[recvLen] = '\0';
|
||
|
|
// std::cout << "Received message: " << recvBuf << std::endl;
|
||
|
|
// } else {
|
||
|
|
// std::cerr << "recv failed with error: " << WSAGetLastError() << std::endl;
|
||
|
|
// }
|
||
|
|
|
||
|
|
// closesocket(sock);
|
||
|
|
// WSACleanup();
|
||
|
|
item->sock_tcp = sock;
|
||
|
|
item->is_connected = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool iobox_api::disconnectToIobox(const std::string& ip) {
|
||
|
|
// check ip is already in iobox_profiles
|
||
|
|
bool is_exist = false;
|
||
|
|
iobox_profile_t* item = nullptr;
|
||
|
|
|
||
|
|
for (auto& profile : this->iobox_profiles) {
|
||
|
|
if (profile.iobox_info.ip_address == ip) {
|
||
|
|
item = &profile;
|
||
|
|
is_exist = true;
|
||
|
|
if (item->is_connected) {
|
||
|
|
std::cout << "Ip is already connected: " << ip << std::endl;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (is_exist == false) {
|
||
|
|
std::cout << "Ip is not exist in list scan" << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
item->counting_get = 0;
|
||
|
|
item->is_connected = false;
|
||
|
|
closesocket(item->sock_tcp);
|
||
|
|
item->sock_tcp = INVALID_SOCKET;
|
||
|
|
// WSACleanup();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint16_t calculateCRC(const uint8_t* data, size_t length) {
|
||
|
|
uint16_t crc = 0xFFFF;
|
||
|
|
for (size_t i = 0; i < length; ++i) {
|
||
|
|
crc ^= data[i];
|
||
|
|
for (int j = 0; j < 8; ++j) {
|
||
|
|
if (crc & 0x0001) {
|
||
|
|
crc >>= 1;
|
||
|
|
crc ^= 0xA001;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
crc >>= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return crc;
|
||
|
|
}
|
||
|
|
std::vector<uint8_t> createModbusWriteSingleRegisterRequest(uint8_t slaveAddress, uint16_t address, uint16_t value) {
|
||
|
|
std::vector<uint8_t> request(8);
|
||
|
|
request[0] = slaveAddress; // Slave address
|
||
|
|
request[1] = 0x06; // Function code for Write Single Register
|
||
|
|
request[2] = (address >> 8) & 0xFF; // Register address high byte
|
||
|
|
request[3] = address & 0xFF; // Register address low byte
|
||
|
|
request[4] = (value >> 8) & 0xFF; // Value high byte
|
||
|
|
request[5] = value & 0xFF; // Value low byte
|
||
|
|
|
||
|
|
// Calculate CRC
|
||
|
|
uint16_t crc = calculateCRC(request.data(), 6);
|
||
|
|
request[6] = crc & 0xFF; // CRC low byte
|
||
|
|
request[7] = (crc >> 8) & 0xFF; // CRC high byte
|
||
|
|
|
||
|
|
return request;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
std::vector<uint8_t> createModbusReadHoldingRegistersRequest(uint8_t slaveAddress, uint16_t startAddress, uint16_t quantity) {
|
||
|
|
std::vector<uint8_t> request(8);
|
||
|
|
request[0] = slaveAddress; // Slave address
|
||
|
|
request[1] = 0x03; // Function code for Read Holding Registers
|
||
|
|
request[2] = (startAddress >> 8) & 0xFF; // Starting address high byte
|
||
|
|
request[3] = startAddress & 0xFF; // Starting address low byte
|
||
|
|
request[4] = (quantity >> 8) & 0xFF; // Quantity of registers high byte
|
||
|
|
request[5] = quantity & 0xFF; // Quantity of registers low byte
|
||
|
|
|
||
|
|
// Calculate CRC
|
||
|
|
uint16_t crc = calculateCRC(request.data(), 6);
|
||
|
|
request[6] = crc & 0xFF; // CRC low byte
|
||
|
|
request[7] = (crc >> 8) & 0xFF; // CRC high byte
|
||
|
|
|
||
|
|
return request;
|
||
|
|
}
|
||
|
|
std::vector<uint16_t> parseModbusReadHoldingRegistersResponse(const std::vector<uint8_t>& response) {
|
||
|
|
std::vector<uint16_t> data;
|
||
|
|
if (response.size() < 5) {
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify CRC
|
||
|
|
uint16_t receivedCrc = (response[response.size() - 1] << 8) | response[response.size() - 2];
|
||
|
|
uint16_t calculatedCrc = calculateCRC(response.data(), response.size() - 2);
|
||
|
|
if (receivedCrc != calculatedCrc) {
|
||
|
|
std::cerr << "CRC check failed" << std::endl;
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
if (response[1] & 0x80) {
|
||
|
|
std::cerr << "Error code received: " << static_cast<int>(response[2]) << std::endl;
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
uint8_t byteCount = response[2];
|
||
|
|
if (response.size() < 5 + byteCount) {
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
for (size_t i = 0; i < byteCount / 2; ++i) {
|
||
|
|
uint16_t value = (response[3 + i * 2] << 8) | response[4 + i * 2];
|
||
|
|
data.push_back(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
iobox_profile_t* iobox_api::findProfileByIp(const std::string& ip) {
|
||
|
|
iobox_profile_t* profile = nullptr;
|
||
|
|
for (auto& item : this->iobox_profiles) {
|
||
|
|
if (item.iobox_info.ip_address == ip) {
|
||
|
|
profile = &item;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return profile;
|
||
|
|
}
|
||
|
|
bool iobox_api::getAllDataFromIobox(const std::string& ip) {
|
||
|
|
iobox_profile_t* profile = findProfileByIp(ip);
|
||
|
|
if (profile == nullptr) {
|
||
|
|
std::cerr << "IP address not found: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
std::vector<uint8_t> request = createModbusReadHoldingRegistersRequest(profile->iobox_info.modbus_address, DEVICE_DATA_ADDRESS, DEVICE_DATA_LENGTH);
|
||
|
|
if (!sendTcpMessage(ip, reinterpret_cast<const char*>(request.data()), request.size())) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
char response[256];
|
||
|
|
size_t responseLength = sizeof(response);
|
||
|
|
if (!receiveTcpMessage(ip, response, responseLength)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::vector<uint8_t> responseVec(response, response + responseLength);
|
||
|
|
std::vector<uint16_t> registers = parseModbusReadHoldingRegistersResponse(responseVec);
|
||
|
|
|
||
|
|
if (registers.empty()) {
|
||
|
|
std::cerr << "Failed to parse Modbus response" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// Process the registers as needed
|
||
|
|
// for (size_t i = 0; i < registers.size(); ++i) {
|
||
|
|
// std::cout << "Register " << i << ": " << registers[i] << std::endl;
|
||
|
|
// }
|
||
|
|
if (registers.size() == DEVICE_DATA_LENGTH) {
|
||
|
|
memcpy(&profile->iobox_data, registers.data(), sizeof(profile->iobox_data));
|
||
|
|
}
|
||
|
|
if (profile->iobox_data.modbus_address != (uint16_t)profile->iobox_info.modbus_address) {
|
||
|
|
std::cout << "Modbus address changed to " << profile->iobox_data.modbus_address << std::endl;
|
||
|
|
profile->iobox_info.modbus_address = profile->iobox_data.modbus_address;
|
||
|
|
}
|
||
|
|
profile->counting_get++;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool iobox_api::setValueDataToIobox(const std::string& ip, uint16_t address, uint16_t value) {
|
||
|
|
iobox_profile_t* profile = findProfileByIp(ip);
|
||
|
|
if (profile == nullptr) {
|
||
|
|
std::cerr << "IP address not found: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
std::vector<uint8_t> request = createModbusWriteSingleRegisterRequest(profile->iobox_info.modbus_address, address, value);
|
||
|
|
if (!sendTcpMessage(ip, reinterpret_cast<const char*>(request.data()), request.size())) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
char response[256];
|
||
|
|
size_t responseLength = sizeof(response);
|
||
|
|
if (!receiveTcpMessage(ip, response, responseLength)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Process the response as needed
|
||
|
|
std::vector<uint8_t> responseVec(response, response + responseLength);
|
||
|
|
if (responseVec.size() < 8) {
|
||
|
|
std::cerr << "Invalid response length" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify CRC
|
||
|
|
uint16_t receivedCrc = (responseVec[7] << 8) | responseVec[6];
|
||
|
|
uint16_t calculatedCrc = calculateCRC(responseVec.data(), 6);
|
||
|
|
if (receivedCrc != calculatedCrc) {
|
||
|
|
std::cerr << "CRC check failed" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if the response matches the request
|
||
|
|
if (responseVec[0] != request[0] || responseVec[1] != request[1] ||
|
||
|
|
responseVec[2] != request[2] || responseVec[3] != request[3] ||
|
||
|
|
responseVec[4] != request[4] || responseVec[5] != request[5]) {
|
||
|
|
std::cerr << "Response does not match the request" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::cout << "Write single register succeeded" << std::endl;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool iobox_api::isValidChannelName(const std::string& channelName) {
|
||
|
|
for (const std::string& name : this->channel_name) {
|
||
|
|
if (name == channelName) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
bool iobox_api::getAllValueIobox(const std::string& ip)
|
||
|
|
{
|
||
|
|
iobox_profile_t* profile = findProfileByIp(ip);
|
||
|
|
if (profile == nullptr) {
|
||
|
|
std::cerr << "IP address not found: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!getAllDataFromIobox(ip)) {
|
||
|
|
std::cerr << "Failed to get data from IOBox: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
std::string iobox_api::getValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName) {
|
||
|
|
if (!isValidChannelName(channelName)) {
|
||
|
|
std::cerr << "Invalid channel name: " << channelName << std::endl;
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
if (!getAllValueIobox(ip)) {
|
||
|
|
std::cerr << "Failed to get all data from IOBox: " << ip << std::endl;
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
int16_t value_int = 0;
|
||
|
|
iobox_profile_t* profile = findProfileByIp(ip);
|
||
|
|
if (profile == nullptr) {
|
||
|
|
std::cerr << "IP address not found: " << ip << std::endl;
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
if (channelName == "DO1") {
|
||
|
|
value_int = profile->iobox_data.channel_DO[0];
|
||
|
|
}
|
||
|
|
else if (channelName == "DO2") {
|
||
|
|
value_int = profile->iobox_data.channel_DO[1];
|
||
|
|
}
|
||
|
|
else if (channelName == "DO3") {
|
||
|
|
value_int = profile->iobox_data.channel_DO[2];
|
||
|
|
}
|
||
|
|
else if (channelName == "DO4") {
|
||
|
|
value_int = profile->iobox_data.channel_DO[3];
|
||
|
|
}
|
||
|
|
else if (channelName == "DI1") {
|
||
|
|
value_int = profile->iobox_data.channel_DI[0];
|
||
|
|
}
|
||
|
|
else if (channelName == "DI2") {
|
||
|
|
value_int = profile->iobox_data.channel_DI[1];
|
||
|
|
}
|
||
|
|
else if (channelName == "DI3") {
|
||
|
|
value_int = profile->iobox_data.channel_DI[2];
|
||
|
|
}
|
||
|
|
else if (channelName == "DI4") {
|
||
|
|
value_int = profile->iobox_data.channel_DI[3];
|
||
|
|
}
|
||
|
|
else if (channelName == "AI1") {
|
||
|
|
value_int = profile->iobox_data.channel_AI[0];
|
||
|
|
}
|
||
|
|
else if (channelName == "AI2") {
|
||
|
|
value_int = profile->iobox_data.channel_AI[1];
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
std::cerr << "Invalid channel name: " << channelName << std::endl;
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
return std::to_string(value_int);
|
||
|
|
}
|
||
|
|
bool iobox_api::setValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName, const std::string& value) {
|
||
|
|
iobox_profile_t* profile = findProfileByIp(ip);
|
||
|
|
if (profile == nullptr) {
|
||
|
|
std::cerr << "IP address not found: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!isValidChannelName(channelName)) {
|
||
|
|
std::cerr << "Invalid channel name: " << channelName << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
int channelIndex = -1;
|
||
|
|
for (channelIndex = 0; channelIndex < IOBOX_CHANNEL_NUM; channelIndex++) {
|
||
|
|
if (this->channel_name[channelIndex] == channelName) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (channelIndex == -1) {
|
||
|
|
std::cerr << "Invalid channel name: " << channelName << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
int16_t value_int = std::stoi(value);
|
||
|
|
if (!setValueDataToIobox(ip, this->iobox_channel_address[channelIndex], value_int)) {
|
||
|
|
std::cerr << "Failed to set data to IOBox: " << ip << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (channelName == "DO1") {
|
||
|
|
profile->iobox_data.channel_DO[0] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DO2") {
|
||
|
|
profile->iobox_data.channel_DO[1] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DO3") {
|
||
|
|
profile->iobox_data.channel_DO[2] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DO4") {
|
||
|
|
profile->iobox_data.channel_DO[3] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DI1") {
|
||
|
|
profile->iobox_data.channel_DI[0] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DI2") {
|
||
|
|
profile->iobox_data.channel_DI[1] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DI3") {
|
||
|
|
profile->iobox_data.channel_DI[2] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "DI4") {
|
||
|
|
profile->iobox_data.channel_DI[3] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "AI1") {
|
||
|
|
profile->iobox_data.channel_AI[0] = value_int;
|
||
|
|
}
|
||
|
|
else if (channelName == "AI2") {
|
||
|
|
profile->iobox_data.channel_AI[1] = value_int;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
std::cerr << "Invalid channel name: " << channelName << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
void testGetAllValueFromChannelName(iobox_api& api, const std::string& ip) {
|
||
|
|
std::vector<std::string> channelNames = { "DO1", "DO2", "DO3", "DO4", "DI1", "DI2", "DI3", "DI4", "AI1", "AI2" };
|
||
|
|
for (const std::string& channelName : channelNames) {
|
||
|
|
std::string value = api.getValueDataStringIoboxFromChannelName(ip, channelName);
|
||
|
|
std::cout << "Channel " << channelName << ": " << value << std::endl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool iobox_api::setAuthenticationIobox(const std::string& ip, const std::string& username, const std::string& password) {
|
||
|
|
// Todo
|
||
|
|
// Override default username and password
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::vector<std::string> iobox_api::getDeviceChannelNames(const std::string& ip, int timeout) {
|
||
|
|
// To do
|
||
|
|
// Get channel names from IOBox (if available)
|
||
|
|
std::vector<std::string> channelNames = { "DO1", "DO2", "DO3", "DO4", "DI1", "DI2", "DI3", "DI4", "AI1", "AI2" };
|
||
|
|
return channelNames;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|