pubsubclient3/api/PubSubClient_8h_source.html

#ifndef PubSubClient_h

#define PubSubClient_h


#include <Arduino.h>


#include "Client.h"

#include "IPAddress.h"

#include "Stream.h"


#define MQTT_VERSION_3_1   3

#define MQTT_VERSION_3_1_1 4


//< @note The following #define directives can be used to configure the library.


#ifndef MQTT_VERSION

#define MQTT_VERSION MQTT_VERSION_3_1_1

#endif


#ifndef MQTT_MAX_POSSIBLE_PACKET_SIZE

#define MQTT_MAX_POSSIBLE_PACKET_SIZE 268435455

#endif


#ifndef MQTT_MAX_PACKET_SIZE

#define MQTT_MAX_PACKET_SIZE 256

#endif


#ifndef MQTT_KEEPALIVE

#define MQTT_KEEPALIVE 15

#endif


#ifndef MQTT_SOCKET_TIMEOUT

#define MQTT_SOCKET_TIMEOUT 15

#endif


#ifndef MQTT_MAX_TRANSFER_SIZE  // just a hack that it gets shown in Doxygen

#define MQTT_MAX_TRANSFER_SIZE 80

#undef MQTT_MAX_TRANSFER_SIZE

#endif


#define MQTT_CONNECTION_TIMEOUT      -4

#define MQTT_CONNECTION_LOST         -3

#define MQTT_CONNECT_FAILED          -2

#define MQTT_DISCONNECTED            -1

#define MQTT_CONNECTED               0

#define MQTT_CONNECT_BAD_PROTOCOL    1

#define MQTT_CONNECT_BAD_CLIENT_ID   2

#define MQTT_CONNECT_UNAVAILABLE     3

#define MQTT_CONNECT_BAD_CREDENTIALS 4

#define MQTT_CONNECT_UNAUTHORIZED    5


#define MQTTRETAINED    1        // Retained flag in the header

#define MQTTCONNECT     1 << 4   // Client request to connect to Server

#define MQTTCONNACK     2 << 4   // Connect Acknowledgment

#define MQTTPUBLISH     3 << 4   // Publish message

#define MQTTPUBACK      4 << 4   // Publish Acknowledgment

#define MQTTPUBREC      5 << 4   // Publish Received (assured delivery part 1)

#define MQTTPUBREL      6 << 4   // Publish Release (assured delivery part 2)

#define MQTTPUBCOMP     7 << 4   // Publish Complete (assured delivery part 3)

#define MQTTSUBSCRIBE   8 << 4   // Client Subscribe request

#define MQTTSUBACK      9 << 4   // Subscribe Acknowledgment

#define MQTTUNSUBSCRIBE 10 << 4  // Client Unsubscribe request

#define MQTTUNSUBACK    11 << 4  // Unsubscribe Acknowledgment

#define MQTTPINGREQ     12 << 4  // PING Request

#define MQTTPINGRESP    13 << 4  // PING Response

#define MQTTDISCONNECT  14 << 4  // Client is Disconnecting

#define MQTTRESERVED    15 << 4  // Reserved


#define MQTT_QOS0 ((uint8_t)0)

#define MQTT_QOS1 ((uint8_t)1)

#define MQTT_QOS2 ((uint8_t)2)

#define MQTT_QOS_GET_HDR(qos) (((qos) & 0x03) << 1) // Get QoS header bits from QoS value

#define MQTT_HDR_GET_QOS(header) (((header) & 0x06 ) >> 1) // Get QoS value from MQTT header


#define MQTT_MAX_HEADER_SIZE 5


#if defined(__has_include) && __has_include(<functional>) && !defined(NOFUNCTIONAL)

#include <functional>

#define MQTT_CALLBACK_SIGNATURE std::function<void(char* topic, uint8_t* payload, size_t plength)> callback

#else

#define MQTT_CALLBACK_SIGNATURE void (*callback)(char* topic, uint8_t* payload, size_t plength)

#endif


#ifdef DEBUG_ESP_PORT

#ifdef DEBUG_PUBSUBCLIENT

#define DEBUG_PSC_PRINTF(fmt, ...) DEBUG_ESP_PORT.printf(("PubSubClient: " fmt), ##__VA_ARGS__)

#else

#define DEBUG_PSC_PRINTF(...)

#endif


#define ERROR_PSC_PRINTF(fmt, ...) DEBUG_ESP_PORT.printf(("PubSubClient error: " fmt), ##__VA_ARGS__)

#define ERROR_PSC_PRINTF_P(fmt, ...) DEBUG_ESP_PORT.printf_P(PSTR("PubSubClient error: " fmt), ##__VA_ARGS__)

#else  // DEBUG_ESP_PORT

#ifndef DEBUG_PSC_PRINTF

#define DEBUG_PSC_PRINTF(...)

#endif

#ifndef ERROR_PSC_PRINTF

#define ERROR_PSC_PRINTF(fmt, ...)

#endif

#ifndef ERROR_PSC_PRINTF_P

#define ERROR_PSC_PRINTF_P(fmt, ...)

#endif

#endif


class PubSubClient : public Print {

   private:

    Client* _client{};

    uint8_t* _buffer{};

    size_t _bufferSize{};

    size_t _bufferWritePos{};

    unsigned long _keepAliveMillis{};

    unsigned long _socketTimeoutMillis{};

    uint16_t _nextMsgId{};

    unsigned long _lastOutActivity{};

    unsigned long _lastInActivity{};

    bool _pingOutstanding{};

    MQTT_CALLBACK_SIGNATURE{};

    IPAddress _ip{};

    char* _domain{};

    uint16_t _port{};

    Stream* _stream{};

    int _state{MQTT_DISCONNECTED};


    size_t readPacket(uint8_t* hdrLen);

    bool handlePacket(uint8_t hdrLen, size_t len);

    bool readByte(uint8_t* result);

    bool readByte(uint8_t* result, size_t* pos);

    uint8_t buildHeader(uint8_t header, size_t length);

    bool writeControlPacket(uint8_t header, size_t length);

    size_t writeBuffer(size_t pos, size_t size);

    size_t writeString(const char* string, size_t pos);

    size_t writeNextMsgId(size_t pos);


    // Add to buffer and flush if full (only to be used with beginPublish/endPublish)

    size_t appendBuffer(uint8_t data);

    size_t flushBuffer();


   public:

    PubSubClient();


    PubSubClient(Client& client);


    PubSubClient(IPAddress addr, uint16_t port, Client& client);


    PubSubClient(IPAddress addr, uint16_t port, Client& client, Stream& stream);


    PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client);


    PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream);


    PubSubClient(uint8_t* ip, uint16_t port, Client& client);


    PubSubClient(uint8_t* ip, uint16_t port, Client& client, Stream& stream);


    PubSubClient(uint8_t* ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client);


    PubSubClient(uint8_t* ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream);


    PubSubClient(const char* domain, uint16_t port, Client& client);


    PubSubClient(const char* domain, uint16_t port, Client& client, Stream& stream);


    PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client);


    PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream);


    ~PubSubClient();


    PubSubClient& setServer(IPAddress ip, uint16_t port);


    PubSubClient& setServer(uint8_t* ip, uint16_t port);


    PubSubClient& setServer(const char* domain, uint16_t port);


    PubSubClient& setCallback(MQTT_CALLBACK_SIGNATURE);


    PubSubClient& setClient(Client& client);


    PubSubClient& setStream(Stream& stream);


    PubSubClient& setKeepAlive(uint16_t keepAlive);


    PubSubClient& setSocketTimeout(uint16_t timeout);


    bool setBufferSize(size_t size);


    size_t getBufferSize();


    bool connect(const char* id);


    bool connect(const char* id, const char* user, const char* pass);


    bool connect(const char* id, const char* willTopic, uint8_t willQos, bool willRetain, const char* willMessage);


    bool connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, bool willRetain, const char* willMessage);


    bool connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, bool willRetain, const char* willMessage,

                 bool cleanSession);


    void disconnect();


    bool publish(const char* topic, const char* payload);


    bool publish(const char* topic, const char* payload, bool retained);


    bool publish(const char* topic, const char* payload, uint8_t qos, bool retained);


    bool publish(const char* topic, const uint8_t* payload, size_t plength);


    bool publish(const char* topic, const uint8_t* payload, size_t plength, bool retained);


    bool publish(const char* topic, const uint8_t* payload, size_t plength, uint8_t qos, bool retained);


    bool publish_P(const char* topic, const char* payload, bool retained);


    bool publish_P(const char* topic, const char* payload, uint8_t qos, bool retained);


    bool publish_P(const char* topic, const uint8_t* payload, size_t plength, bool retained);


    bool publish_P(const char* topic, const uint8_t* payload, size_t plength, uint8_t qos, bool retained);


    bool beginPublish(const char* topic, size_t plength, bool retained);


    bool beginPublish(const char* topic, size_t plength, uint8_t qos, bool retained);


    bool endPublish();


    virtual size_t write(uint8_t data);


    virtual size_t write(const uint8_t* buf, size_t size);


    size_t write_P(const uint8_t* buf, size_t size);


    bool subscribe(const char* topic);


    bool subscribe(const char* topic, uint8_t qos);


    bool unsubscribe(const char* topic);


    bool loop();


    bool connected();


    int state();

};


#endif

PubSubClient::loop
bool loop()
This should be called regularly to allow the client to process incoming messages and maintain its con...
Definition PubSubClient.cpp:472

PubSubClient::subscribe
bool subscribe(const char *topic)
Subscribes to messages published to the specified topic using QoS 0.
Definition PubSubClient.cpp:787

PubSubClient::setCallback
PubSubClient & setCallback(MQTT_CALLBACK_SIGNATURE)
Sets the message callback function.
Definition PubSubClient.cpp:858

PubSubClient::setServer
PubSubClient & setServer(IPAddress ip, uint16_t port)
Sets the server details.
Definition PubSubClient.cpp:833

PubSubClient::beginPublish
bool beginPublish(const char *topic, size_t plength, bool retained)
Start to publish a message using QoS 0. This API: beginPublish(...) one or more calls to write(....
Definition PubSubClient.cpp:568

PubSubClient::unsubscribe
bool unsubscribe(const char *topic)
Unsubscribes from the specified topic.
Definition PubSubClient.cpp:811

PubSubClient::publish_P
bool publish_P(const char *topic, const char *payload, bool retained)
Publishes a message stored in PROGMEM to the specified topic using QoS 0.
Definition PubSubClient.cpp:548

PubSubClient::write
virtual size_t write(uint8_t data)
Writes a single byte as a component of a publish started with a call to beginPublish....
Definition PubSubClient.cpp:644

PubSubClient::publish
bool publish(const char *topic, const char *payload)
Publishes a non retained message to the specified topic using QoS 0.
Definition PubSubClient.cpp:520

PubSubClient::~PubSubClient
~PubSubClient()
Destructor for the PubSubClient class.
Definition PubSubClient.cpp:108

PubSubClient::setSocketTimeout
PubSubClient & setSocketTimeout(uint16_t timeout)
Sets the socket timeout used by the client. This determines how long the client will wait for incomin...
Definition PubSubClient.cpp:901

PubSubClient::PubSubClient
PubSubClient()
Creates an uninitialised client instance.
Definition PubSubClient.cpp:26

PubSubClient::setKeepAlive
PubSubClient & setKeepAlive(uint16_t keepAlive)
Sets the keep alive interval used by the client. This value should only be changed when the client is...
Definition PubSubClient.cpp:896

PubSubClient::connected
bool connected()
Checks whether the client is connected to the server.
Definition PubSubClient.cpp:234

PubSubClient::state
int state()
Returns the current state of the client. If a connection attempt fails, this can be used to get more ...
Definition PubSubClient.cpp:906

PubSubClient::endPublish
bool endPublish()
Finish sending a message that was started with a call to beginPublish.
Definition PubSubClient.cpp:600

PubSubClient::setClient
PubSubClient & setClient(Client &client)
Sets the network client instance to use.
Definition PubSubClient.cpp:863

PubSubClient::disconnect
void disconnect()
Disconnects the client.
Definition PubSubClient.cpp:248

PubSubClient::getBufferSize
size_t getBufferSize()
Gets the current size of the internal buffer.
Definition PubSubClient.cpp:892

PubSubClient::write_P
size_t write_P(const uint8_t *buf, size_t size)
Writes an array of progmem bytes as a component of a publish started with a call to beginPublish....
Definition PubSubClient.cpp:655

PubSubClient::setBufferSize
bool setBufferSize(size_t size)
Sets the size, in bytes, of the internal send and receive buffer. This must be large enough to contai...
Definition PubSubClient.cpp:873

PubSubClient::connect
bool connect(const char *id)
Connects the client using a clean session without username and password.
Definition PubSubClient.cpp:113

PubSubClient::setStream
PubSubClient & setStream(Stream &stream)
Sets the stream to write received messages to.
Definition PubSubClient.cpp:868

MQTT_DISCONNECTED
#define MQTT_DISCONNECTED
The client is disconnected cleanly.
Definition PubSubClient.h:89