Detección rápida de multidifusión CoAP
Uso del cliente CoAP para el descubrimiento de recursos de multidifusión con una interfaz de usuario « Qt Quick ».

El ejemplo «Descubrimiento rápido de multidifusión CoAP » muestra cómo registrar ` QCoapClient ` como un tipo QML y utilizarlo en una aplicación Qt Quick para el descubrimiento de recursos de multidifusión CoAP.
Nota: Qt CoAP no proporciona una API de QML en su versión actual. Sin embargo, puedes hacer que las clases de C++ del módulo estén disponibles para QML tal y como se muestra en este ejemplo.
Ejecución del ejemplo
Puede ejecutar el ejemplo desde:
- Qt Creator
Abre el modo « Welcome » y selecciona el ejemplo en Examples. Para obtener más información, consulta Qt Creator: Tutorial: Compilar y ejecutar.
- Qt Extension for Visual Studio Code
Ejecuta el comando « Qt: Open Qt examples » desde Command Palette y selecciona el ejemplo de la lista. Para obtener más información, consulta Qt Extension for Visual Studio Code: Tutorial: Compilar y ejecutar.
Configuración de un servidor CoAP
Para ejecutar la aplicación de ejemplo, primero debes configurar e iniciar al menos un servidor CoAP que admita el descubrimiento de recursos por multidifusión. Dispones de las siguientes opciones:
- Compilar y ejecutar manualmente servidores CoAP utilizando libcoap, Californium o cualquier otra implementación de servidor CoAP que admita las funciones de multidifusión y descubrimiento de recursos.
- Utilizar la imagen de Docker ya preparada disponible en Docker Hub, que compila e inicia un servidor CoAP basado en el ejemplo de servidor de multidifusión de Californium.
Uso del servidor de prueba basado en Docker
El siguiente comando descarga el contenedor de Docker para el servidor CoAP desde Docker Hub y lo inicia:
docker run --name coap-multicast-server -d --rm --net=host tqtc/coap-multicast-test-server:californium-2.0.0Nota: Puedes ejecutar más de un servidor CoAP de multidifusión (en el mismo host o en otros hosts de la red) pasando un --name diferente al comando anterior.
Para cerrar el contenedor de Docker tras su uso, primero obtén el ID del contenedor ejecutando el comando docker ps. El resultado será similar a este:
$ docker ps
CONTAINER ID IMAGE
8b991fae7789 tqtc/coap-multicast-test-server:californium-2.0.0A continuación, utiliza este ID para detener el contenedor:
docker stop <container_id>Exposición de clases de C++ a QML
En este ejemplo, es necesario exponer las clases ` QCoapResource ` y ` QCoapClient `, así como el espacio de nombres ` QtCoap `, a QML. Para ello, crea clases envolventes personalizadas y utiliza las macros de registro especiales.
Crea la clase ` QmlCoapResource ` como envoltura de ` QCoapResource`. Utiliza la macro ` Q_PROPERTY ` para que varias propiedades sean accesibles desde QML. No es necesario que la clase se pueda instanciar directamente desde QML, así que utiliza la macro ` QML_ANONYMOUS ` para registrarla.
class QmlCoapResource : public QCoapResource
{
Q_GADGET
Q_PROPERTY(QString title READ title)
Q_PROPERTY(QString host READ hostStr)
Q_PROPERTY(QString path READ path)
QML_ANONYMOUS
public:
QmlCoapResource() : QCoapResource() {}
QmlCoapResource(const QCoapResource &resource)
: QCoapResource(resource) {}
QString hostStr() const { return host().toString(); }
};A continuación, crea la clase QmlCoapMulticastClient con la clase QCoapClient como clase base. Utiliza la macro Q_PROPERTY para exponer una propiedad personalizada y crea también varios métodos Q_INVOKABLE. Se puede acceder tanto a la propiedad como a los métodos invocables desde QML. A diferencia de QmlCoapResource, es deseable poder crear esta clase desde QML, por lo que debes utilizar la macro QML_NAMED_ELEMENT para registrar la clase en QML.
class QmlCoapMulticastClient : public QCoapClient
{
Q_OBJECT
Q_PROPERTY(bool isDiscovering READ isDiscovering NOTIFY isDiscoveringChanged)
QML_NAMED_ELEMENT(CoapMulticastClient)
public:
QmlCoapMulticastClient(QObject *parent = nullptr);
Q_INVOKABLE void discover(const QString &host, int port, const QString &discoveryPath);
Q_INVOKABLE void discover(QtCoap::MulticastGroup group, int port, const QString &discoveryPath);
Q_INVOKABLE void stopDiscovery();
bool isDiscovering() const;
Q_SIGNALS:
void discovered(const QmlCoapResource &resource);
void finished(int error);
// The bool parameter is not provided, because the signal is only used by
// the QML property system, and it does not use the passed value anyway.
void isDiscoveringChanged();
public slots:
void onDiscovered(QCoapResourceDiscoveryReply *reply, const QList<QCoapResource> &resources);
private:
QCoapResourceDiscoveryReply *m_reply = nullptr;
};Por último, registra el espacio de nombres QtCoap, para que puedas utilizar las enumeraciones que allí se proporcionan:
namespace QCoapForeignNamespace
{
Q_NAMESPACE
QML_FOREIGN_NAMESPACE(QtCoap)
QML_NAMED_ELEMENT(QtCoap)
}Ajuste de los archivos de compilación
Para que los tipos personalizados estén disponibles desde QML, actualiza los archivos del sistema de compilación según corresponda.
Compilación con CMake
Para una compilación basada en CMake, añade lo siguiente al archivo CMakeLists.txt:
qt_add_qml_module(quickmulticastclient
URI CoapClientModule
VERSION 1.0
SOURCES
qmlcoapmulticastclient.cpp qmlcoapmulticastclient.h
QML_FILES
Main.qml
)Compilación con qmake
Para una compilación con qmake, modifica el archivo quickmulticastclient.pro de la siguiente manera:
CONFIG += qmltypes
QML_IMPORT_NAME = CoapClientModule
QML_IMPORT_MAJOR_VERSION = 1
...
qml_resources.files = \
qmldir \
Main.qml
qml_resources.prefix = /qt/qml/CoapClientModule
RESOURCES += qml_resourcesUso de los nuevos tipos de QML
Ahora que las clases de C++ están correctamente expuestas a QML, puedes utilizar los nuevos tipos:
CoapMulticastClient {
id: client
onDiscovered: (resource) => { root.addResource(resource) }
onFinished: (error) => {
statusLabel.text = (error === QtCoap.Error.Ok)
? qsTr("Finished resource discovery.")
: qsTr("Resource discovery failed with error code: %1").arg(error)
}
}La señal « QmlCoapMulticastClient::finished() » activa el controlador de señales « onFinished », para mostrar el estado de la solicitud en la interfaz de usuario. Ten en cuenta que el ejemplo no utiliza directamente las señales de « QCoapClient », ya que tanto la señal « error()» como la « finished()» toman como parámetro un « QCoapReply » (que no está expuesto a QML), y el ejemplo solo requiere el código de error.
El constructor de ` QmlCoapMulticastClient` reenvía las señales de ` QCoapClient` a la señal ` QmlCoapMulticastClient::finished() `:
QmlCoapMulticastClient::QmlCoapMulticastClient(QObject *parent)
: QCoapClient(QtCoap::SecurityMode::NoSecurity, parent)
{
connect(this, &QCoapClient::finished, this,
[this](QCoapReply *reply) {
if (reply) {
emit finished(static_cast<int>(reply->errorReceived()));
reply->deleteLater();
if (m_reply == reply) {
m_reply = nullptr;
emit isDiscoveringChanged();
}
} else {
qCWarning(lcCoapClient, "Something went wrong, received a null reply");
}
});
connect(this, &QCoapClient::error, this,
[this](QCoapReply *, QtCoap::Error err) {
emit finished(static_cast<int>(err));
});
}Al pulsar el botón « Discover », se invoca uno de los métodos sobrecargados de « discover() », en función del grupo de multidifusión seleccionado:
Button {
id: discoverButton
text: client.isDiscovering ? qsTr("Stop Discovery") : qsTr("Discover")
Layout.preferredWidth: 100
onClicked: {
if (client.isDiscovering) {
client.stopDiscovery()
} else {
var currentGroup = groupComboBox.model.get(groupComboBox.currentIndex).value;
var path = "";
if (currentGroup !== - 1) {
client.discover(currentGroup, parseInt(portField.text),
discoveryPathField.text);
path = groupComboBox.currentText;
} else {
client.discover(customGroupField.text, parseInt(portField.text),
discoveryPathField.text);
path = customGroupField.text + discoveryPathField.text;
}
statusLabel.text = qsTr("Discovering resources at %1...").arg(path);
}
}
}Esta sobrecarga se invoca cuando se selecciona un grupo de multidifusión personalizado o una dirección de host:
void QmlCoapMulticastClient::discover(const QString &host, int port, const QString &discoveryPath)
{
QUrl url;
url.setHost(host);
url.setPort(port);
m_reply = QCoapClient::discover(url, discoveryPath);
if (m_reply) {
connect(m_reply, &QCoapResourceDiscoveryReply::discovered,
this, &QmlCoapMulticastClient::onDiscovered);
emit isDiscoveringChanged();
} else {
qCWarning(lcCoapClient, "Discovery request failed.");
}
}Y esta sobrecarga se invoca cuando se selecciona uno de los grupos de multidifusión sugeridos en la interfaz de usuario:
void QmlCoapMulticastClient::discover(QtCoap::MulticastGroup group, int port,
const QString &discoveryPath)
{
m_reply = QCoapClient::discover(group, port, discoveryPath);
if (m_reply) {
connect(m_reply, &QCoapResourceDiscoveryReply::discovered,
this, &QmlCoapMulticastClient::onDiscovered);
emit isDiscoveringChanged();
} else {
qCWarning(lcCoapClient, "Discovery request failed.");
}
}La señal « QCoapResourceDiscoveryReply::discovered()» proporciona una lista de « QCoapResources», que no es un tipo QML. Para que los recursos estén disponibles en QML, reenvía cada recurso de la lista a la señal « QmlCoapMulticastClient::discovered() », que admite un « QmlCoapResource » en su lugar:
void QmlCoapMulticastClient::onDiscovered(QCoapResourceDiscoveryReply *reply,
const QList<QCoapResource> &resources)
{
Q_UNUSED(reply)
for (const auto &resource : resources)
emit discovered(resource);
}Los recursos detectados se añaden a la resourceModel de la vista de lista en la interfaz de usuario:
function addResource(resource) {
resourceModel.insert(0, {"host" : resource.host,
"path" : resource.path,
"title" : resource.title})
}Mientras se está llevando a cabo la detección, pulsa el botón « Stop Discovery » para detenerla. Internamente, esto se realiza abortando la solicitud actual:
void QmlCoapMulticastClient::stopDiscovery()
{
if (m_reply)
m_reply->abortRequest();
}Archivos:
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.