Update MediaClient
This commit is contained in:
BIN
IOBox/Backup/v1.0.0/flow_chart.jpg
Normal file
BIN
IOBox/Backup/v1.0.0/flow_chart.jpg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 118 KiB |
729
IOBox/Backup/v1.0.0/iobox_api.cpp
Normal file
729
IOBox/Backup/v1.0.0/iobox_api.cpp
Normal file
@@ -0,0 +1,729 @@
|
||||
#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;
|
||||
}
|
||||
|
||||
}
|
||||
124
IOBox/Backup/v1.0.0/iobox_api.h
Normal file
124
IOBox/Backup/v1.0.0/iobox_api.h
Normal file
@@ -0,0 +1,124 @@
|
||||
#ifndef _IO_BOX_API_H
|
||||
#define _IO_BOX_API_H
|
||||
#define ANSIO_API __declspec(dllexport)
|
||||
|
||||
#pragma once
|
||||
#include "extcode.h"
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
#include <chrono>
|
||||
|
||||
#pragma comment(lib,"WS2_32")
|
||||
// #pragma comment(lib, "Ws2_32.lib")
|
||||
// #define TEST_FIX_IP
|
||||
#define DEVICE_TCP_PORT 502
|
||||
#define DEVICE_DATA_ADDRESS 100
|
||||
#define DEVICE_DATA_LENGTH 17
|
||||
|
||||
namespace ANSCENTER {
|
||||
typedef struct {
|
||||
std::string ip_address;
|
||||
uint8_t modbus_address;
|
||||
} iobox_info_t;
|
||||
typedef union {
|
||||
/* data */
|
||||
uint16_t raw_data[DEVICE_DATA_LENGTH];
|
||||
struct
|
||||
{
|
||||
uint16_t modbus_address;
|
||||
uint8_t serial_number[10];
|
||||
uint16_t version;
|
||||
int16_t channel_DO[4];
|
||||
int16_t channel_DI[4];
|
||||
int16_t channel_AI[2];
|
||||
};
|
||||
} iobox_data_t;
|
||||
typedef enum {
|
||||
IOBOX_CHANNEL_DO1 = 0,
|
||||
IOBOX_CHANNEL_DO2,
|
||||
IOBOX_CHANNEL_DO3,
|
||||
IOBOX_CHANNEL_DO4,
|
||||
IOBOX_CHANNEL_DI1,
|
||||
IOBOX_CHANNEL_DI2,
|
||||
IOBOX_CHANNEL_DI3,
|
||||
IOBOX_CHANNEL_DI4,
|
||||
IOBOX_CHANNEL_AI1,
|
||||
IOBOX_CHANNEL_AI2,
|
||||
IOBOX_CHANNEL_NUM
|
||||
} iobox_channel_t;
|
||||
typedef struct {
|
||||
int counting_get;
|
||||
bool is_connected;
|
||||
SOCKET sock_tcp;
|
||||
iobox_info_t iobox_info;
|
||||
iobox_data_t iobox_data;
|
||||
|
||||
} iobox_profile_t;
|
||||
class ANSIO_API iobox_api
|
||||
{
|
||||
private:
|
||||
std::string ip_mcast; //ip multicast
|
||||
int port_mcast; //port multicast
|
||||
std::string channel_name[IOBOX_CHANNEL_NUM] = {
|
||||
"DO1", "DO2", "DO3", "DO4",
|
||||
"DI1", "DI2", "DI3", "DI4",
|
||||
"AI1", "AI2"
|
||||
};
|
||||
uint16_t iobox_channel_address[IOBOX_CHANNEL_NUM] = {
|
||||
107, 108, 109, 110, 111, 112, 113, 114, 115, 116
|
||||
};
|
||||
std::vector<iobox_profile_t> iobox_profiles;
|
||||
iobox_profile_t* findProfileByIp(const std::string& ip);
|
||||
void save_info_iobox(iobox_info_t iobox_info);
|
||||
void setSocketTimeout(SOCKET sock, int timeout);
|
||||
void sendMulticastMessage(const std::string& message);
|
||||
bool sendTcpMessage(const std::string& ip, const char* buffer, size_t length);
|
||||
bool receiveTcpMessage(const std::string& ip, char* buffer, size_t& length);
|
||||
bool getAllDataFromIobox(const std::string& ip);
|
||||
bool setValueDataToIobox(const std::string& ip, uint16_t address, uint16_t value);
|
||||
bool isValidChannelName(const std::string& channelName);
|
||||
void show_profile_iobox(iobox_profile_t profile);
|
||||
public:
|
||||
iobox_api(std::string ip_mcast, int port_mcast);
|
||||
~iobox_api();
|
||||
void show_profile_iobox(std::string ip);
|
||||
void show_profile_ioboxs();
|
||||
std::vector<std::string> scanNetworkDevicesMulticast(int timeout);
|
||||
bool setAuthenticationIobox(const std::string& ip, const std::string& username, const std::string& password);
|
||||
bool resetAuthenticationIobox(const std::string& ip, const std::string& token) { return true; }
|
||||
bool resetIobox(const std::string& ip, const std::string& token) { return true; }
|
||||
bool connectToIobox(const std::string& ip, int port, const std::string& username, const std::string& password);
|
||||
bool disconnectToIobox(const std::string& ip);
|
||||
std::vector<std::string> getDeviceChannelNames(const std::string& ip,int timeout);
|
||||
std::string getValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName);
|
||||
bool setValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName, const std::string& value);
|
||||
bool getAllValueIobox(const std::string& ip);
|
||||
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
extern "C" ANSIO_API int CreateANSIOHandle(ANSCENTER::iobox_api** Handle, const char* multicastIPAddress, int multicastPort);
|
||||
extern "C" ANSIO_API int ScanANSIOHandle(ANSCENTER::iobox_api** Handle, int timeout, LStrHandle ipAddresses);
|
||||
extern "C" ANSIO_API int ConnectANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, int ioBoxPort, const char* userName, const char* passWord);
|
||||
extern "C" ANSIO_API int DisconnectANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP);
|
||||
extern "C" ANSIO_API int GetChannelNamesANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP,int timeout, LStrHandle channelNames);
|
||||
extern "C" ANSIO_API int SetValueANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, const char* channelName, const char* value);
|
||||
extern "C" ANSIO_API int GetValueANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, const char* channelName, LStrHandle lStrValue);
|
||||
extern "C" ANSIO_API int SetAuthenticationANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, const char* userName, const char* passWord);
|
||||
extern "C" ANSIO_API int ReleaseANSIOHandle(ANSCENTER::iobox_api** Handle);
|
||||
extern "C" ANSIO_API int ResetAuthenticationANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, const char* token);
|
||||
extern "C" ANSIO_API int ResetANSIOHandle(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, const char* token);
|
||||
|
||||
// C++ interface
|
||||
extern "C" ANSIO_API int ScanANSIOHandle_CPP(ANSCENTER::iobox_api** Handle, int timeout, std::string& ipAddresses);
|
||||
extern "C" ANSIO_API int GetChannelNamesANSIOHandle_CPP(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, int timeout, std::string& channelNames);
|
||||
extern "C" ANSIO_API int GetValueANSIOHandle_CPP(ANSCENTER::iobox_api** Handle, const char* ioBoxIP, const char* channelName, std::string& lStrValue);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
91
IOBox/Backup/v1.0.0/main.cpp
Normal file
91
IOBox/Backup/v1.0.0/main.cpp
Normal file
@@ -0,0 +1,91 @@
|
||||
|
||||
#include "iobox_api.h"
|
||||
#include <thread>
|
||||
|
||||
iobox_api ioBoxApp((char*)"239.255.255.250", 12345);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void userInputThread(iobox_api* api) {
|
||||
std::string current_ip;
|
||||
|
||||
while (true) {
|
||||
std::string input;
|
||||
std::cout << std::endl;
|
||||
std::cout << "Enter command followed by Enter: exit, scan, setip, connect, disconnect, show, get, set" << std::endl;
|
||||
// std::cin >> input; // This will only get the first word
|
||||
std::getline(std::cin, input);
|
||||
if (input == "exit") {
|
||||
break;
|
||||
}
|
||||
else if(input == "scan") {
|
||||
std::vector<std::string> devices = api->scanNetworkDevicesMulticast(5);
|
||||
std::cout << "Found devices: " << devices.size() << std::endl;
|
||||
for (const std::string& device : devices) {
|
||||
std::cout << device << std::endl;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if(input == "setip") {
|
||||
std::cout << "Enter IP: ";
|
||||
std::getline(std::cin, current_ip);
|
||||
continue;
|
||||
}
|
||||
else if(input == "connect") {
|
||||
if(current_ip == "") {
|
||||
std::cout << "Please setip address first" << std::endl;
|
||||
continue;
|
||||
}
|
||||
bool connect = api->connectToIobox(current_ip, DEVICE_TCP_PORT);
|
||||
std::cout << "Connection to " << current_ip << (connect ? " succeeded." : " failed.") << std::endl;
|
||||
continue;
|
||||
}
|
||||
else if(input == "disconnect") {
|
||||
bool disconnect = api->disconnectToIobox(current_ip);
|
||||
std::cout << "Disconnect to " << current_ip << (disconnect ? " succeeded." : " failed.") << std::endl;
|
||||
// current_ip = "";
|
||||
continue;
|
||||
}
|
||||
else if(input == "show") {
|
||||
api->show_profile_ioboxs();
|
||||
continue;
|
||||
}
|
||||
else if(input == "get") {
|
||||
std::string channel;
|
||||
std::cout << "Enter channel (\"all\" for get all): ";
|
||||
std::cin >> channel;
|
||||
if(channel == "all") {
|
||||
bool get = api->getAllValueIobox(current_ip);
|
||||
api->show_profile_iobox(current_ip);
|
||||
std::cout << "Get all value from " << current_ip << (get ? " succeeded." : " failed.") << std::endl;
|
||||
} else {
|
||||
std::string value = api->getValueDataStringIoboxFromChannelName(current_ip, channel);
|
||||
std::cout << "Value of " << channel << ": " << value << std::endl;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if(input == "set") {
|
||||
std::string value;
|
||||
std::string channel;
|
||||
std::cout << "Enter channel: ";
|
||||
std::cin >> channel;
|
||||
std::cout << "Enter value: ";
|
||||
std::cin >> value;
|
||||
bool set = api->setValueDataStringIoboxFromChannelName(current_ip, channel, value);
|
||||
std::cout << "Set value to " << current_ip << (set ? " succeeded." : " failed.") << std::endl;
|
||||
}
|
||||
else {
|
||||
std::cout << "Invalid command" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
|
||||
std::thread userThread(userInputThread, &ioBoxApp);
|
||||
userThread.join();
|
||||
|
||||
std::cout << "Main thread is done" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
54
IOBox/Backup/v1.0.0/readme.md
Normal file
54
IOBox/Backup/v1.0.0/readme.md
Normal file
@@ -0,0 +1,54 @@
|
||||
### IOBOX API USAGE GUIDE
|
||||
This document provides an overview and usage instructions for the APIs available in `iobox_api.h`.
|
||||
#### 1. Api name and features
|
||||
* Scan
|
||||
|
||||
`std::vector<std::string> scanNetworkDevicesMulticast(int timeout);`
|
||||
|
||||
API need to be passed a timeout in second unit. The API will return a list of IPs as a vector string.
|
||||
* Connect
|
||||
|
||||
`bool connectToIobox(const std::string& ip, int port); `
|
||||
|
||||
Connect to a specific IP device from list of IPs above. Default port is 502.
|
||||
|
||||
* Disconnect
|
||||
|
||||
`bool disconnectToIobox(const std::string& ip);`
|
||||
|
||||
Disconnect to a specific IP device that is connected before
|
||||
|
||||
* Get value of channel
|
||||
|
||||
`std::string getValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName);`
|
||||
|
||||
Get value of specific channel name from a IP device that is connected before.
|
||||
List of channel name is included in `channel_name` array.
|
||||
|
||||
* Set value of channel
|
||||
|
||||
`bool setValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName, const std::string& value);`
|
||||
|
||||
Set a value of specific channel name from a IP device that is connected before. List of channel name is included in `channel_name` array.
|
||||
|
||||
#### 2. How to using example test in main.cpp
|
||||
|
||||
You need build this project before run by using g++ compiler
|
||||
|
||||
`g++ .\*.cpp -lws2_32 -o main.exe`
|
||||
|
||||
Then you need only running `main.exe`.
|
||||
|
||||
Start application, it will show
|
||||
|
||||
`Enter command followed by Enter: exit, scan, setip, connect, disconnect, show, get, set`
|
||||
|
||||
* You type `scan`, it will scan all device iobox on local network then it will list them on terminal attach their IP address if they is found.
|
||||
* Then type `setip` to setup IP of iobox you need to connect
|
||||
Then you will be required to input of specific IP address and you need type IP you want.
|
||||
* Next you type `connect` to connect to this IP device
|
||||
* Then you can use `get` or `set` command to continue get or set value to any channel.
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user