1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* This example shows how to publish messages from outside of the Mosquitto network loop.
*/
#include <mosquitto.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/* Callback called when the client receives a CONNACK message from the broker. */
void on_connect(struct mosquitto *mosq, void *obj, int reason_code)
{
/* Print out the connection result. mosquitto_connack_string() produces an
* appropriate string for MQTT v3.x clients, the equivalent for MQTT v5.0
* clients is mosquitto_reason_string().
*/
printf("on_connect: %s\n", mosquitto_connack_string(reason_code));
if(reason_code != 0){
/* If the connection fails for any reason, we don't want to keep on
* retrying in this example, so disconnect. Without this, the client
* will attempt to reconnect. */
mosquitto_disconnect(mosq);
}
/* You may wish to set a flag here to indicate to your application that the
* client is now connected. */
}
/* Callback called when the client knows to the best of its abilities that a
* PUBLISH has been successfully sent. For QoS 0 this means the message has
* been completely written to the operating system. For QoS 1 this means we
* have received a PUBACK from the broker. For QoS 2 this means we have
* received a PUBCOMP from the broker. */
void on_publish(struct mosquitto *mosq, void *obj, int mid)
{
printf("Message with mid %d has been published.\n", mid);
}
int get_temperature(void)
{
sleep(1); /* Prevent a storm of messages - this pretend sensor works at 1Hz */
return random()%100;
}
/* This function pretends to read some data from a sensor and publish it.*/
void publish_sensor_data(struct mosquitto *mosq)
{
char payload[20];
int temp;
int rc;
/* Get our pretend data */
temp = get_temperature();
/* Print it to a string for easy human reading - payload format is highly
* application dependent. */
snprintf(payload, sizeof(payload), "%d", temp);
/* Publish the message
* mosq - our client instance
* *mid = NULL - we don't want to know what the message id for this message is
* topic = "example/temperature" - the topic on which this message will be published
* payloadlen = strlen(payload) - the length of our payload in bytes
* payload - the actual payload
* qos = 2 - publish with QoS 2 for this example
* retain = false - do not use the retained message feature for this message
*/
rc = mosquitto_publish(mosq, NULL, "example/temperature", strlen(payload), payload, 2, false);
if(rc != MOSQ_ERR_SUCCESS){
fprintf(stderr, "Error publishing: %s\n", mosquitto_strerror(rc));
}
}
int main(int argc, char *argv[])
{
struct mosquitto *mosq;
int rc;
/* Required before calling other mosquitto functions */
mosquitto_lib_init();
/* Create a new client instance.
* id = NULL -> ask the broker to generate a client id for us
* clean session = true -> the broker should remove old sessions when we connect
* obj = NULL -> we aren't passing any of our private data for callbacks
*/
mosq = mosquitto_new(NULL, true, NULL);
if(mosq == NULL){
fprintf(stderr, "Error: Out of memory.\n");
return 1;
}
/* Configure callbacks. This should be done before connecting ideally. */
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_publish_callback_set(mosq, on_publish);
/* Connect to test.mosquitto.org on port 1883, with a keepalive of 60 seconds.
* This call makes the socket connection only, it does not complete the MQTT
* CONNECT/CONNACK flow, you should use mosquitto_loop_start() or
* mosquitto_loop_forever() for processing net traffic. */
rc = mosquitto_connect(mosq, "test.mosquitto.org", 1883, 60);
if(rc != MOSQ_ERR_SUCCESS){
mosquitto_destroy(mosq);
fprintf(stderr, "Error: %s\n", mosquitto_strerror(rc));
return 1;
}
/* Run the network loop in a background thread, this call returns quickly. */
rc = mosquitto_loop_start(mosq);
if(rc != MOSQ_ERR_SUCCESS){
mosquitto_destroy(mosq);
fprintf(stderr, "Error: %s\n", mosquitto_strerror(rc));
return 1;
}
/* At this point the client is connected to the network socket, but may not
* have completed CONNECT/CONNACK.
* It is fairly safe to start queuing messages at this point, but if you
* want to be really sure you should wait until after a successful call to
* the connect callback.
* In this case we know it is 1 second before we start publishing.
*/
while(1){
publish_sensor_data(mosq);
}
mosquitto_lib_cleanup();
return 0;
}
|
