-
Notifications
You must be signed in to change notification settings - Fork 2.4k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
1 changed file
with
128 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,128 @@ | ||
/* | ||
* 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)); | ||
|
||
/* 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; | ||
} | ||
|