kangjun/SL100_FactoryTestTool
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新与前板的使用串口连接

Browse Source
This commit is contained in:
钟富强
2025-02-14 11:06:28 +08:00
parent d2bccd9c49
commit aa3e8c8223
301 changed files with 5373 additions and 512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
FactoryTestTool/SourceCode/Network/mdns/MdnsServiceThread.h
View File

@@ -4,12 +4,13 @@
#include "mdns.h"
// 添加一个类来运行 mDNS 服务
// 运行 mDNS 服务
class MdnsServiceThread : public QThread {
Q_OBJECT
public:
MdnsServiceThread(const QString& hostname, const QString& serviceName, int servicePort, QObject* parent = nullptr)
MdnsServiceThread(const QString& hostname, const QString& serviceName, int servicePort, char* select_ip, QObject* parent = nullptr)
: QThread(parent),
m_select_ip(select_ip),
m_hostname(hostname),
m_serviceName(serviceName),
m_servicePort(servicePort) {}
@@ -26,8 +27,9 @@ protected:
extern volatile sig_atomic_t running; // 使用全局变量控制运行状态
running = 1;
// 调用阻塞的 service_mdns 方法
int result = service_mdns(m_hostname.toStdString().c_str(), m_serviceName.toStdString().c_str(), m_servicePort);
//int result = service_mdns(m_hostname.toStdString().c_str(), m_serviceName.toStdString().c_str(), m_servicePort, "192.168.1.170");
//int result = service_mdns(m_hostname.toStdString().c_str(), m_serviceName.toStdString().c_str(), m_servicePort, "172.17.128.1");
int result = service_mdns(m_hostname.toStdString().c_str(), m_serviceName.toStdString().c_str(), m_servicePort, m_select_ip);
if (result < 0) {
qDebug() << "Failed to start mDNS service";
}
@@ -37,6 +39,7 @@ protected:
}
private:
char* m_select_ip;
QString m_hostname;
QString m_serviceName;
int m_servicePort;

283
FactoryTestTool/SourceCode/Network/mdns/mdns.c
View File

@@ -530,7 +530,7 @@ open_client_sockets(int* sockets, int max_sockets, int port) {
char buffer[128];
mdns_string_t addr = ipv4_address_to_string(buffer, sizeof(buffer), saddr,
sizeof(struct sockaddr_in));
printf("Local IPv4 address: %.*s\n", MDNS_STRING_FORMAT(addr));
printf("---Local IPv4 address: %.*s\n", MDNS_STRING_FORMAT(addr));
}
}
} else if (unicast->Address.lpSockaddr->sa_family == AF_INET6) {
@@ -665,6 +665,7 @@ open_client_sockets(int* sockets, int max_sockets, int port) {
return num_sockets;
}
/*
// Open sockets to listen to incoming mDNS queries on port 5353
static int
open_service_sockets(int* sockets, int max_sockets) {
@@ -720,6 +721,101 @@ open_service_sockets(int* sockets, int max_sockets) {
return num_sockets;
}
*/
static int open_service_sockets(int* sockets, int max_sockets, const char* local_ip) {
int num_sockets = 0;
if (local_ip) {
// <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD> local_ip<69><70><EFBFBD><EFBFBD><EFBFBD>󶨵<EFBFBD><F3B6A8B5>õ<EFBFBD>ַ
struct sockaddr_in sock_addr_ipv4;
struct sockaddr_in6 sock_addr_ipv6;
memset(&sock_addr_ipv4, 0, sizeof(sock_addr_ipv4));
memset(&sock_addr_ipv6, 0, sizeof(sock_addr_ipv6));
if (inet_pton(AF_INET, local_ip, &sock_addr_ipv4.sin_addr)) {
sock_addr_ipv4.sin_family = AF_INET;
sock_addr_ipv4.sin_port = htons(MDNS_PORT);
#ifdef __APPLE__
sock_addr_ipv4.sin_len = sizeof(struct sockaddr_in);
#endif
int sock = mdns_socket_open_ipv4(&sock_addr_ipv4);
if (sock >= 0) {
sockets[num_sockets++] = sock;
printf("Bound to specific IPv4 address: %s\n", local_ip);
}
else {
printf("Failed to bind to IPv4 address: %s\n", local_ip);
}
}
else if (inet_pton(AF_INET6, local_ip, &sock_addr_ipv6.sin6_addr)) {
sock_addr_ipv6.sin6_family = AF_INET6;
sock_addr_ipv6.sin6_port = htons(MDNS_PORT);
#ifdef __APPLE__
sock_addr_ipv6.sin6_len = sizeof(struct sockaddr_in6);
#endif
int sock = mdns_socket_open_ipv6(&sock_addr_ipv6);
if (sock >= 0) {
sockets[num_sockets++] = sock;
printf("Bound to specific IPv6 address: %s\n", local_ip);
}
else {
printf("Failed to bind to IPv6 address: %s\n", local_ip);
}
}
else {
printf("Invalid local IP address: %s\n", local_ip);
}
}
if (num_sockets == 0) {
// <20><><EFBFBD><EFBFBD>δָ<CEB4><D6B8> local_ip<69><70><EFBFBD><EFBFBD><EFBFBD>󶨵<EFBFBD><F3B6A8B5><EFBFBD><EFBFBD>нӿ<D0BD>
if (num_sockets < max_sockets) {
struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
#ifdef _WIN32
sock_addr.sin_addr = in4addr_any;
#else
sock_addr.sin_addr.s_addr = INADDR_ANY;
#endif
sock_addr.sin_port = htons(MDNS_PORT);
#ifdef __APPLE__
sock_addr.sin_len = sizeof(struct sockaddr_in);
#endif
int sock = mdns_socket_open_ipv4(&sock_addr);
if (sock >= 0) {
sockets[num_sockets++] = sock;
printf("IPv4 socket opened successfully on port %d\n", MDNS_PORT);
}
else {
printf("Failed to open IPv4 socket on port %d\n", MDNS_PORT);
}
}
if (num_sockets < max_sockets) {
struct sockaddr_in6 sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin6_family = AF_INET6;
sock_addr.sin6_addr = in6addr_any;
sock_addr.sin6_port = htons(MDNS_PORT);
#ifdef __APPLE__
sock_addr.sin6_len = sizeof(struct sockaddr_in6);
#endif
int sock = mdns_socket_open_ipv6(&sock_addr);
if (sock >= 0) {
sockets[num_sockets++] = sock;
printf("IPv6 socket opened successfully on port %d\n", MDNS_PORT);
}
else {
printf("Failed to open IPv6 socket on port %d\n", MDNS_PORT);
}
}
}
return num_sockets;
}
// Send a DNS-SD query
static int
@@ -862,10 +958,12 @@ send_mdns_query(mdns_query_t* query, size_t count, void* user_data) {
}
// Provide a mDNS service, answering incoming DNS-SD and mDNS queries
/*
int
service_mdns(const char* hostname, const char* service_name, int service_port) {
service_mdns(const char* hostname, const char* service_name, int service_port, const char* local_ip) {
int sockets[32];
int num_sockets = open_service_sockets(sockets, sizeof(sockets) / sizeof(sockets[0]));
//int num_sockets = open_service_sockets(sockets, sizeof(sockets) / sizeof(sockets[0]));
int num_sockets = open_service_sockets(sockets, sizeof(sockets) / sizeof(sockets[0]), local_ip);
if (num_sockets <= 0) {
printf("Failed to open any client sockets\n");
return -1;
@@ -1037,6 +1135,183 @@ service_mdns(const char* hostname, const char* service_name, int service_port) {
mdns_socket_close(sockets[isock]);
printf("Closed socket%s\n", num_sockets ? "s" : "");
return 0;
}*/
int service_mdns(const char* hostname, const char* service_name, int service_port, const char* local_ip) {
int sockets[32];
int num_sockets = open_service_sockets(sockets, sizeof(sockets) / sizeof(sockets[0]), local_ip);
if (num_sockets <= 0) {
printf("Failed to open any client sockets\n");
return -1;
}
printf("Opened %d socket%s for mDNS service\n", num_sockets, num_sockets ? "s" : "");
size_t service_name_length = strlen(service_name);
if (!service_name_length) {
printf("Invalid service name\n");
return -1;
}
char* service_name_buffer = malloc(service_name_length + 2);
memcpy(service_name_buffer, service_name, service_name_length);
if (service_name_buffer[service_name_length - 1] != '.')
service_name_buffer[service_name_length++] = '.';
service_name_buffer[service_name_length] = 0;
service_name = service_name_buffer;
printf("Service mDNS: %s:%d\n", service_name, service_port);
printf("Hostname: %s\n", hostname);
size_t capacity = 2048;
void* buffer = malloc(capacity);
mdns_string_t service_string = (mdns_string_t){service_name, strlen(service_name)};
mdns_string_t hostname_string = (mdns_string_t){hostname, strlen(hostname)};
char service_instance_buffer[256] = {0};
snprintf(service_instance_buffer, sizeof(service_instance_buffer) - 1, "%.*s.%.*s",
MDNS_STRING_FORMAT(hostname_string), MDNS_STRING_FORMAT(service_string));
mdns_string_t service_instance_string =
(mdns_string_t){service_instance_buffer, strlen(service_instance_buffer)};
char qualified_hostname_buffer[256] = {0};
snprintf(qualified_hostname_buffer, sizeof(qualified_hostname_buffer) - 1, "%.*s.local.",
MDNS_STRING_FORMAT(hostname_string));
mdns_string_t hostname_qualified_string =
(mdns_string_t){qualified_hostname_buffer, strlen(qualified_hostname_buffer)};
service_t service = {0};
service.service = service_string;
service.hostname = hostname_string;
service.service_instance = service_instance_string;
service.hostname_qualified = hostname_qualified_string;
service.port = service_port;
if (local_ip) {
struct sockaddr_in addr_ipv4;
memset(&addr_ipv4, 0, sizeof(addr_ipv4));
addr_ipv4.sin_family = AF_INET;
if (inet_pton(AF_INET, local_ip, &addr_ipv4.sin_addr) <= 0) {
printf("Invalid local IP address: %s\n", local_ip);
free(service_name_buffer);
free(buffer);
return -1;
}
service.address_ipv4 = addr_ipv4;
} else {
service.address_ipv4 = service_address_ipv4;
}
// Setup mDNS records
service.record_ptr = (mdns_record_t){
.name = service.service,
.type = MDNS_RECORDTYPE_PTR,
.data.ptr.name = service.service_instance,
.rclass = 0,
.ttl = 120
};
service.record_srv = (mdns_record_t){
.name = service.service_instance,
.type = MDNS_RECORDTYPE_SRV,
.data.srv.name = service.hostname_qualified,
.data.srv.port = service.port,
.data.srv.priority = 0,
.data.srv.weight = 0,
.rclass = 0,
.ttl = 120
};
service.record_a = (mdns_record_t){
.name = service.hostname_qualified,
.type = MDNS_RECORDTYPE_A,
.data.a.addr = service.address_ipv4,
.rclass = 0,
.ttl = 120
};
service.record_aaaa = (mdns_record_t){
.name = service.hostname_qualified,
.type = MDNS_RECORDTYPE_AAAA,
.data.aaaa.addr = service.address_ipv6,
.rclass = 0,
.ttl = 120
};
service.txt_record[0] = (mdns_record_t){
.name = service.service_instance,
.type = MDNS_RECORDTYPE_TXT,
.data.txt.key = {MDNS_STRING_CONST("test")},
.data.txt.value = {MDNS_STRING_CONST("1")},
.rclass = 0,
.ttl = 120
};
service.txt_record[1] = (mdns_record_t){
.name = service.service_instance,
.type = MDNS_RECORDTYPE_TXT,
.data.txt.key = {MDNS_STRING_CONST("other")},
.data.txt.value = {MDNS_STRING_CONST("value")},
.rclass = 0,
.ttl = 120
};
printf("Sending announce\n");
mdns_record_t additional[5] = {0};
size_t additional_count = 0;
additional[additional_count++] = service.record_srv;
additional[additional_count++] = service.record_a;
additional[additional_count++] = service.txt_record[0];
additional[additional_count++] = service.txt_record[1];
for (int isock = 0; isock < num_sockets; ++isock)
mdns_announce_multicast(sockets[isock], buffer, capacity, service.record_ptr, 0, 0, additional, additional_count);
// Service loop
while (running) {
int nfds = 0;
fd_set readfs;
FD_ZERO(&readfs);
for (int isock = 0; isock < num_sockets; ++isock) {
if (sockets[isock] >= nfds)
nfds = sockets[isock] + 1;
FD_SET(sockets[isock], &readfs);
}
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 100000;
if (select(nfds, &readfs, 0, 0, &timeout) >= 0) {
for (int isock = 0; isock < num_sockets; ++isock) {
if (FD_ISSET(sockets[isock], &readfs)) {
mdns_socket_listen(sockets[isock], buffer, capacity, service_callback, &service);
}
FD_SET(sockets[isock], &readfs);
}
} else {
break;
}
}
printf("Sending goodbye\n");
additional_count = 0;
additional[additional_count++] = service.record_srv;
additional[additional_count++] = service.record_a;
additional[additional_count++] = service.txt_record[0];
additional[additional_count++] = service.txt_record[1];
for (int isock = 0; isock < num_sockets; ++isock)
mdns_goodbye_multicast(sockets[isock], buffer, capacity, service.record_ptr, 0, 0, additional, additional_count);
free(buffer);
free(service_name_buffer);
for (int isock = 0; isock < num_sockets; ++isock)
mdns_socket_close(sockets[isock]);
printf("Closed socket%s\n", num_sockets > 1 ? "s" : "");
return 0;
}
@@ -1045,7 +1320,7 @@ service_mdns(const char* hostname, const char* service_name, int service_port) {
static int
dump_mdns(void) {
int sockets[32];
int num_sockets = open_service_sockets(sockets, sizeof(sockets) / sizeof(sockets[0]));
int num_sockets = open_service_sockets(sockets, sizeof(sockets) / sizeof(sockets[0]), "192.168.1.170");
if (num_sockets <= 0) {
printf("Failed to open any client sockets\n");
return -1;

2
FactoryTestTool/SourceCode/Network/mdns/mdns.h
View File

@@ -177,7 +177,7 @@ struct mdns_query_t {
};
int
service_mdns(const char* hostname, const char* service_name, int service_port);
service_mdns(const char* hostname, const char* service_name, int service_port, const char* local_ip);
// mDNS/DNS-SD public API