物联网协议：介绍MQTT、CoAP等常见物联网协议及其在Linux上的实现

物联网(IoT)设备需要通过网络进行通信，这就需要使用特定的协议来管理数据传输。MQTT和CoAP是两种常见的物联网协议，本文将介绍这两种协议及其在Linux上的实现。???? 1. MQTT协议???? 1.1 什么是MQTTMQTT(Message Queuing Telemetry Transport)是一种轻量级的发布...

egzosn

1113人浏览 · 2024-10-22 17:12:16

egzosn · 2024-10-22 17:12:16 发布

物联网(IoT)设备需要通过网络进行通信，这就需要使用特定的协议来管理数据传输。MQTT和CoAP是两种常见的物联网协议，本文将介绍这两种协议及其在Linux上的实现。

物联网协议：介绍MQTT、CoAP等常见物联网协议及其在Linux上的实现_物联网

📚 1. MQTT协议

🧩 1.1 什么是MQTT

MQTT(Message Queuing Telemetry Transport)是一种轻量级的发布/订阅消息传输协议，专为低带宽、不可靠网络环境设计。它通常用于物联网设备之间的通信。

🔧 1.2 MQTT的基本概念

Broker：消息代理服务器，负责接收和分发消息。
Client：客户端，可以是发布者或订阅者。
Topic：消息主题，客户端通过订阅特定主题来接收消息。
QoS(Quality of Service)：服务质量等级，定义消息传输的可靠性。

📝 1.3 在Linux上实现MQTT

安装MQTT Broker(Mosquitto)

Mosquitto是一个开源的MQTT Broker，实现了MQTT协议。

在Ubuntu上安装Mosquitto

sudo apt-get update
sudo apt-get install mosquitto mosquitto-clients
sudo systemctl start mosquitto
sudo systemctl enable mosquitto

在其他Linux发行版上安装Mosquitto

可以从官方网站下载源码并编译安装。

使用Mosquitto客户端发布和订阅消息

发布消息

订阅消息

🔍 1.4 使用Python实现MQTT客户端

可以使用paho-mqtt库在Python中实现MQTT客户端。

安装paho-mqtt库

示例代码

发布者

import paho.mqtt.client as mqtt

broker = "localhost"
topic = "test/topic"
message = "Hello, MQTT"

client = mqtt.Client()
client.connect(broker)
client.publish(topic, message)
client.disconnect()

订阅者

import paho.mqtt.client as mqtt

broker = "localhost"
topic = "test/topic"

def on_message(client, userdata, message):
    print("Received message:", str(message.payload.decode("utf-8")))

client = mqtt.Client()
client.connect(broker)
client.subscribe(topic)
client.on_message = on_message
client.loop_forever()

🌐 2. CoAP协议

🧩 2.1 什么是CoAP

CoAP(Constrained Application Protocol)是一种专为资源受限设备设计的应用层协议，基于REST模型，使用UDP进行通信。它适用于低功耗、低带宽的物联网环境。

🔧 2.2 CoAP的基本概念

Client：客户端，发送请求并接收响应。
Server：服务器，接收请求并发送响应。
Resource：资源，服务器上的可访问对象。
Method：方法，包括GET、POST、PUT、DELETE等。

📝 2.3 在Linux上实现CoAP

安装CoAP库(libcoap)

libcoap是一个开源的CoAP库，实现了CoAP协议。

在Ubuntu上安装libcoap

在其他Linux发行版上安装libcoap

可以从 GitHub下载源码并编译安装。

使用libcoap实现CoAP客户端和服务器

示例代码

服务器

#include <coap2/coap.h>

void response_handler(coap_context_t *ctx, coap_resource_t *resource,
                      coap_session_t *session, coap_pdu_t *request,
                      coap_binary_t *token, coap_string_t *query,
                      coap_pdu_t *response) {
    unsigned char buf[3];
    const char* response_data = "Hello, CoAP";
    response->code = COAP_RESPONSE_CODE(205);
    coap_add_data(response, strlen(response_data), (const unsigned char *)response_data);
}

int main(void) {
    coap_context_t *ctx;
    coap_address_t serv_addr;
    coap_resource_t *resource;

    coap_startup();
    coap_address_init(&serv_addr);
    serv_addr.addr.sin.sin_family = AF_INET;
    serv_addr.addr.sin.sin_addr.s_addr = INADDR_ANY;
    serv_addr.addr.sin.sin_port = htons(5683);

    ctx = coap_new_context(NULL);
    if (!ctx) {
        return -1;
    }

    resource = coap_resource_init(coap_make_str_const("test"), 0);
    coap_register_handler(resource, COAP_REQUEST_GET, response_handler);
    coap_add_resource(ctx, resource);

    coap_run_once(ctx, 0);

    coap_free_context(ctx);
    coap_cleanup();

    return 0;
}

客户端

#include <coap2/coap.h>

void message_handler(struct coap_context_t *ctx, coap_session_t *session,
                     coap_pdu_t *sent, coap_pdu_t *received,
                     const coap_tid_t id) {
    unsigned char* data;
    size_t data_len;

    if (COAP_RESPONSE_CLASS(received->code) == 2) {
        if (coap_get_data(received, &data_len, &data)) {
            printf("Received: %.*s\n", (int)data_len, data);
        }
    }
}

int main(void) {
    coap_context_t *ctx;
    coap_address_t dst_addr;
    coap_session_t *session;
    coap_pdu_t *pdu;

    coap_startup();
    coap_address_init(&dst_addr);
    dst_addr.addr.sin.sin_family = AF_INET;
    dst_addr.addr.sin.sin_addr.s_addr = inet_addr("127.0.0.1");
    dst_addr.addr.sin.sin_port = htons(5683);

    ctx = coap_new_context(NULL);
    if (!ctx) {
        return -1;
    }

    session = coap_new_client_session(ctx, NULL, &dst_addr, COAP_PROTO_UDP);
    if (!session) {
        coap_free_context(ctx);
        return -1;
    }

    pdu = coap_pdu_init(COAP_MESSAGE_CON, COAP_REQUEST_GET, coap_new_message_id(session), coap_session_max_pdu_size(session));
    coap_add_option(pdu, COAP_OPTION_URI_PATH, 4, (const uint8_t *)"test");

    coap_register_response_handler(ctx, message_handler);

    coap_send(session, pdu);

    coap_run_once(ctx, 0);

    coap_session_release(session);
    coap_free_context(ctx);
    coap_cleanup();

    return 0;
}

🔍 2.4 使用Python实现CoAP客户端

可以使用aiocoap库在Python中实现CoAP客户端。

安装aiocoap库

示例代码

客户端

import asyncio
from aiocoap import *

async def main():
    protocol = await Context.create_client_context()

    request = Message(code=GET, uri='coap://localhost/test')

    try:
        response = await protocol.request(request).response
    except Exception as e:
        print('Failed to fetch resource:')
        print(e)
    else:
        print('Result: %s\n%r' % (response.code, response.payload))

if __name__ == "__main__":
    asyncio.run(main())