Sternenlabor/nuki_hub
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

compile with esp mqtt lib

Browse Source
This commit is contained in:
technyon
2023-01-27 19:29:13 +01:00
parent 10650c1132
commit c9dbbb5dc1
113 changed files with 9740 additions and 2997 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
lib/espMqttClient/LICENSE Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2022 Bert Melis
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

54
lib/espMqttClient/README.md Normal file
View File

@@ -0,0 +1,54 @@
# espMqttClient
MQTT client library for the Espressif devices ESP8266 and ESP32 on the Arduino framework.
Aims to be a non-blocking, fully compliant MQTT 3.1.1 client.
![platformio](https://github.com/bertmelis/espMqttClient/actions/workflows/build_platformio.yml/badge.svg)
![cpplint](https://github.com/bertmelis/espMqttClient/actions/workflows/cpplint.yml/badge.svg)
![cppcheck](https://github.com/bertmelis/espMqttClient/actions/workflows/cppcheck.yml/badge.svg)
[![PlatformIO Registry](https://badges.registry.platformio.org/packages/bertmelis/library/espMqttClient.svg)](https://registry.platformio.org/libraries/bertmelis/espMqttClient)
# Features
- MQTT 3.1.1 compliant library
- Sending and receiving at all QoS levels
- TCP and TCP/TLS using standard WiFiClient and WiFiClientSecure connections
- Virtually unlimited incoming and outgoing payload sizes
- Readable and understandable code
- Fully async clients available via [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) or [ESPAsnycTCP](https://github.com/me-no-dev/ESPAsyncTCP) (no TLS supported)
- Supported platforms:
- Espressif ESP8266 and ESP32 using the Arduino framework
- Basic Linux compatibility*. This includes WSL on Windows
> Linux compatibility is mainly for automatic testing. It relies on a quick and dirty Arduino-style `Client` with a POSIX TCP client underneath and Arduino-style `IPAddress` class. These are lacking many features needed for proper Linux support.
# Documentation
See [documentation](https://www.emelis.net/espMqttClient/) and the [examples](examples/).
## Limitations
### MQTT 3.1.1 Compliancy
Outgoing messages and session data are not stored in non-volatile memory. Any events like loss of power or sudden resets result in loss of data. Despite this limitation, one could still consider this library as fully complaint based on the non normative remark in point 4.1.1 of the specification.
### Non-blocking
This library aims to be fully non-blocking. It is however limited by the underlying `WiFiClient` library which is part of the Arduino framework and has a blocking `connect` method. This is not an issue on ESP32 because the call is offloaded to a separate task. On ESP8266 however, connecting will block until succesful or until the connection timeouts.
If you need a fully asynchronous MQTT client, you can use `espMqttClientAsync` which uses AsyncTCP/ESPAsyncTCP under the hood. These underlying libraries do not support TLS (anymore). I will not provide support TLS for the async client.
# Bugs and feature requests
Please use Github's facilities to get in touch.
# About this library
This client wouldn't exist without [Async-mqtt-client](https://github.com/marvinroger/async-mqtt-client). It has been my go-to MQTT client for many years. It was fast, reliable and had features that were non-existing in alternative libraries. However, the underlying async TCP libraries are lacking updates, especially updates related to secure connections. Adapting this library to use up-to-date TCP clients would not be trivial. I eventually decided to write my own MQTT library, from scratch.
The result is an almost non-blocking library with no external dependencies. The library is almost a drop-in replacement for the async-mqtt-client except a few parameter type changes (eg. `uint8_t*` instead of `char*` for payloads).
# License
This library is released under the MIT Licence. A copy is included in the repo.
Parts of this library, most notably the API, are based on [Async MQTT client for ESP8266 and ESP32](https://github.com/marvinroger/async-mqtt-client).

6
lib/espMqttClient/docs/_config.yml Normal file
View File

@@ -0,0 +1,6 @@
theme: jekyll-theme-cayman
title: espMqttClient
description: |
MQTT client library for the Espressif devices ESP8266 and ESP32 on the Arduino framework.
Aims to be a non-blocking fully compliant MQTT 3.1.1 client.
show_downloads: false

487
lib/espMqttClient/docs/index.md Normal file
View File

@@ -0,0 +1,487 @@
![platformio](https://github.com/bertmelis/espMqttClient/actions/workflows/build_platformio.yml/badge.svg)
![cpplint](https://github.com/bertmelis/espMqttClient/actions/workflows/cpplint.yml/badge.svg)
![cppcheck](https://github.com/bertmelis/espMqttClient/actions/workflows/cppcheck.yml/badge.svg)
[![PlatformIO Registry](https://badges.registry.platformio.org/packages/bertmelis/library/espMqttClient.svg)](https://registry.platformio.org/libraries/bertmelis/espMqttClient)
# Features
- MQTT 3.1.1 compliant library
- Sending and receiving at all QoS levels
- TCP and TCP/TLS using standard WiFiClient and WiFiClientSecure connections
- Virtually unlimited incoming and outgoing payload sizes
- Readable and understandable code
- Fully async clients available via [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) or [ESPAsnycTCP](https://github.com/me-no-dev/ESPAsyncTCP) (no TLS supported)
- Supported platforms:
- Espressif ESP8266 and ESP32 using the Arduino framework
- Basic Linux compatibility*. This includes WSL on Windows
> Linux compatibility is mainly for automatic testing. It relies on a quick and dirty Arduino-style `Client` with a POSIX TCP client underneath and Arduino-style `IPAddress` class. These are lacking many features needed for proper Linux support.
# Contents
1. [Runtime behaviour](#runtime-behaviour)
2. [API Reference](#api-reference)
3. [Compile-time configuration](#compile-time-configuration)
4. [Code samples](#code-samples)
# Runtime behaviour
A normal operation cycle of an MQTT client goes like this:
1. setup the client
2. connect to the broker
3. subscribe/publish/receive
4. disconnect/reconnect when disconnected
5. Cleanly disconnect
### Setup
Setting up the client means to tell which host and port to connect to, possible credentials to use and so on. espMqttClient has a set of methods to configure the client. Setup is generally done in the `setup()` function of the Arduino framework.
One important thing to remember is that there are a number of settings that are not stored inside the library: `username`, `password`, `willTopic`, `willPayload`, `clientId` and `host`. Make sure these variables stay available during the lifetime of the `espMqttClient`.
For TLS secured connections, the relevant methods from `WiFiClientSecure` have been made available to setup the TLS mechanisms.
### Connecting
After setting up the client, you are ready to connect. A simple call to `connect()` does the job. If you set an `OnConnectCallback`, you will be notified when the connection has been made. On failure, `OnDisconnectCallback` will be called. Although good code structure can avoid this, you can call `connect()` multiple times.
### Subscribing, publishing and receiving
Once connected, you can subscribe, publish and receive. The methods to do this return the packetId of the generated packet or `1` for packets without packetId. In case of an error, the method returns `0`. When the client is not connected, you cannot subscribe, unsubscribe or publish (configurable, see [EMC_ALLOW_NOT_CONNECTED_PUBLISH](#EMC_ALLOW_NOT_CONNECTED_PUBLISH)).
Receiving packets is done via the `onMessage`-callback. This callback gives you the topic, properties (qos, dup, retain, packetId) and payload. For the payload, you get a pointer to the data, the index, length and total length. On long payloads it is normal that you get multiple callbacks for the same packet. This way, you can receive payloads longer than what could fit in the microcontroller's memory.
> Beware that MQTT payloads are binary. MQTT payloads are **not** c-strings unless explicitely constructed like that. You therefore can **not** print the payload to your Serial monitor without supporting code.
### Disconnecting
You can disconnect from the broker by calling `disconnect()`. If you do not force-disconnect, the client will first send the remaining messages that are in the queue and disconnect afterwards. During this period however, no new incoming PUBLISH messages will be processed.
# API Reference
```cpp
espMqttClient()
espMqttClientSecure()
espMqttClientAsync()
```
Instantiate a new espMqttClient or espMqttSecure object.
On ESP32, two optional parameters are available: `espMqttClient(uint8_t priority = 1, uint8_t core = 1)`. This will change the priority of the MQTT client task and the core on which it runs (higher priority = more cpu-time).
For the asynchronous version, use `espMqttClientAsync`.
### Configuration
```cpp
espMqttClient& setKeepAlive(uint16_t keepAlive)
```
Set the keep alive. Defaults to 15 seconds.
* **`keepAlive`**: Keep alive in seconds
```cpp
espMqttClient& setClientId(const char* clientId)
```
Set the client ID. Defaults to `esp8266123456` or `esp32123456` where `123456` is the chip ID.
The library only stores a pointer to the client ID. Make sure the variable pointed to stays available throughout the lifetime of espMqttClient.
- **`clientId`**: Client ID, expects a null-terminated char array (c-string)
```cpp
espMqttClient& setCleanSession(bool cleanSession)
```
Set the CleanSession flag. Defaults to `true`.
- **`cleanSession`**: clean session wanted or not
```cpp
espMqttClient& setCredentials(const char* username, const char* password)
```
Set the username/password. Defaults to non-auth.
The library only stores a pointer to the username and password. Make sure the variable to pointed stays available throughout the lifetime of espMqttClient.
- **`username`**: Username, expects a null-terminated char array (c-string)
- **`password`**: Password, expects a null-terminated char array (c-string)
```cpp
espMqttClient& setWill(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length)
```
Set the Last Will. Defaults to none.
The library only stores a pointer to the topic and payload. Make sure the variable pointed to stays available throughout the lifetime of espMqttClient.
- **`topic`**: Topic of the LWT, expects a null-terminated char array (c-string)
- **`qos`**: QoS of the LWT
- **`retain`**: Retain flag of the LWT
- **`payload`**: Payload of the LWT.
- **`length`**: Payload length
```cpp
espMqttClient& setWill(const char* topic, uint8_t qos, bool retain, const char* payload)
```
Set the Last Will. Defaults to none.
The library only stores a pointer to the topic and payload. Make sure the variable pointed to stays available throughout the lifetime of espMqttClient.
- **`topic`**: Topic of the LWT, expects a null-terminated char array (c-string)
- **`qos`**: QoS of the LWT
- **`retain`**: Retain flag of the LWT
- **`payload`**: Payload of the LWT, expects a null-terminated char array (c-string). Its lenght will be calculated using `strlen(payload)`
```cpp
espMqttClient& setServer(IPAddress ip, uint16_t port)
```
Set the server. Mind that when using `espMqttClientSecure` with a certificate, the hostname will be chacked against the certificate. Often IP-addresses are not valid and the connection will fail.
- **`ip`**: IP of the server
- **`port`**: Port of the server
```cpp
espMqttClient& setServer(const char* host, uint16_t port)
```
Set the server.
- **`host`**: Host of the server, expects a null-terminated char array (c-string)
- **`port`**: Port of the server
#### Options for TLS connections
All common options from WiFiClientSecure to setup an encrypted connection are made available. These include:
- `espMqttClientSecure& setInsecure()`
- `espMqttClientSecure& setCACert(const char* rootCA)` (ESP32 only)
- `espMqttClientSecure& setCertificate(const char* clientCa)` (ESP32 only)
- `espMqttClientSecure& setPrivateKey(const char* privateKey)` (ESP32 only)
- `espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey)` (ESP32 only)
- `espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20])` (ESP8266 only)
- `espMqttClientSecure& setTrustAnchors(const X509List *ta)` (ESP8266 only)
- `espMqttClientSecure& setClientRSACert(const X509List *cert, const PrivateKey *sk)` (ESP8266 only)
- `espMqttClientSecure& setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type)` (ESP8266 only)
- `espMqttClientSecure& setCertStore(CertStoreBase *certStore)` (ESP8266 only)
For documenation, please visit [ESP8266's documentation](https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/readme.html#bearssl-client-secure-and-server-secure) or [ESP32's documentation](https://github.com/espressif/arduino-esp32/tree/master/libraries/WiFiClientSecure).
### Events handlers
```cpp
espMqttClient& onConnect(espMqttClientTypes::OnConnectCallback callback)
```
Add a connect event handler. Function signature: `void(bool sessionPresent)`
- **`callback`**: Function to call
```cpp
espMqttClient& onDisconnect(espMqttClientTypes::OnDisconnectCallback callback)
```
Add a disconnect event handler. Function signature: `void(espMqttClientTypes::DisconnectReason reason)`
- **`callback`**: Function to call
```cpp
espMqttClient& onSubscribe(espMqttClientTypes::OnSubscribeCallback callback)
```
Add a subscribe acknowledged event handler. Function signature: `void(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* returncodes, size_t len)`
- **`callback`**: Function to call
```cpp
espMqttClient& onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback)
```
Add an unsubscribe acknowledged event handler. Function signature: `void(uint16_t packetId)`
- **`callback`**: Function to call
```cpp
espMqttClient& onMessage(espMqttClientTypes::OnMessageCallback callback)
```
Add a publish received event handler. Function signature: `void(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total)`
- **`callback`**: Function to call
```cpp
espMqttClient& onPublish(espMqttClientTypes::OnPublishCallback callback)
```
Add a publish acknowledged event handler. Function signature: `void(uint16_t packetId)`
- **`callback`**: Function to call
### Operational functions
```cpp
bool connected()
```
Returns if the client is currently fully connected to the broker or not. During connecting or disconnecting, it will return false.
```cpp
bool disconnected()
```
Returns if the client is currently disconnected to the broker or not. During disconnecting or connecting, it will return false.
```cpp
void connect()
```
Connect to the server.
```cpp
void disconnect(bool force = false)
```
Disconnect from the server.
When disconnecting with `force` false, the client first tries to handle all the outgoing messages in the queue and disconnect cleanly afterwards. During this time, no incoming PUBLISH messages are handled.
- **`force`**: Whether to force the disconnection. Defaults to `false` (clean disconnection).
```cpp
uint16_t subscribe(const char* topic, uint8_t qos)
```
Subscribe to the given topic at the given QoS. Return the packet ID or 0 if failed.
- **`topic`**: Topic, expects a null-terminated char array (c-string)
- **`qos`**: QoS
It is also possible to subscribe to multiple topics at once. Just add the topic/qos pairs to the parameters:
```cpp
uint16_t packetId = yourclient.subscribe(topic1, qos1, topic2, qos2, topic3, qos3); // add as many topics as you like*
```
```cpp
uint16_t unsubscribe(const char* topic)
```
Unsubscribe from the given topic. Return the packet ID or 0 if failed.
- **`topic`**: Topic, expects a null-terminated char array (c-string)
It is also possible to unsubscribe to multiple topics at once. Just add the topics to the parameters:
```cpp
uint16_t packetId = yourclient.unsubscribe(topic1, topic2, topic3); // add as many topics as you like*
```
```cpp
uint16_t publish(const char* topic, uint8_t qos, bool retain, const uint8* payload, size_t length)
```
Publish a packet. Return the packet ID (or 1 if QoS 0) or 0 if failed. The topic and payload will be buffered by the library.
- **`topic`**: Topic, expects a null-terminated char array (c-string)
- **`qos`**: QoS
- **`retain`**: Retain flag
- **`payload`**: Payload
- **`length`**: Payload length
```cpp
uint16_t publish(const char* topic, uint8_t qos, bool retain, const char* payload)
```
Publish a packet. Return the packet ID (or 1 if QoS 0) or 0 if failed. The topic and payload will be buffered by the library.
- **`topic`**: Topic, expects a null-terminated char array (c-string)
- **`qos`**: QoS
- **`retain`**: Retain flag
- **`payload`**: Payload, expects a null-terminated char array (c-string). Its lenght will be calculated using `strlen(payload)`
```cpp
uint16_t publish(const char* topic, uint8_t qos, bool retain, espMqttClientTypes::PayloadCallback callback, size_t length)
```
Publish a packet with a callback for payload handling. Return the packet ID (or 1 if QoS 0) or 0 if failed. The topic will be buffered by the library.
- **`topic`**: Topic, expects a null-terminated char array (c-string)
- **`qos`**: QoS
- **`retain`**: Retain flag
- **`callback`**: callback to fetch the payload.
The callback has the following signature: `size_t callback(uint8_t* data, size_t maxSize, size_t index)`. When the library needs payload data, the callback will be invoked. It is the callback's job to write data indo `data` with a maximum of `maxSize` bytes, according the `index` and return the amount of bytes written.
```cpp
void clearQueue()
```
When disconnected, clears all queued messages.
Keep in mind that this also deletes any session data and therefore is no MQTT compliant.
```cpp
void loop()
```
This is the worker function of the MQTT client. For ESP8266 you must call this function in the Arduino loop. For ESP32 this function is only used internally and is not available in the API.
```cpp
const char* getClientId() const
```
Retuns the client ID.
# Compile time configuration
A number of constants which influence the behaviour of the client can be set at compile time. You can set these options in the `Config.h` file or pass the values as compiler flags. Because these options are compile-time constants, they are used for all instances of `espMqttClient` you create in your program.
### EMC_RX_BUFFER_SIZE 1440
The client copies incoming data into a buffer before parsing. This sets the buffer size.
### EMC_TX_BUFFER_SIZE 1440
When publishing using the callback, the client fetches data in chunks of EMC_TX_BUFFER_SIZE size. This is not necessarily the same as the actual outging TCP packets.
### EMC_MAX_TOPIC_LENGTH 128
For **incoming** messages, a maximum topic length is set. Topics longer than this will be truncated.
### EMC_PAYLOAD_BUFFER_SIZE 32
Set the incoming payload buffer size for SUBACK messages. When subscribing to multiple topics at once, the acknowledgement contains all the return codes in its payload. The detault of 32 means you can theoretically subscribe to 32 topics at once.
### EMC_MIN_FREE_MEMORY 4096
The client keeps all outgoing packets in a queue which stores its data in heap memory. With this option, you can set the minimum available (contiguous) heap memory that needs to be available for adding a message to the queue.
### EMC_ESP8266_MULTITHREADING 0
Set this to 1 if you use the async version on ESP8266. For the regular client this setting can be kept disabled because the ESP8266 doesn't use multithreading and is only single-core.
### EMC_ALLOW_NOT_CONNECTED_PUBLISH 1
By default, you can publish when the client is not connected. If you don't want this, set this to 0.
### EMC_CLIENTID_LENGTH 18 + 1
The (maximum) length of the client ID. (Keep in mind that this is a c-string. You need to have 1 position available for the null-termination.)
### EMC_TASK_STACK_SIZE 5000
Only used on ESP32. Sets the stack size (in words) of the MQTT client worker task.
### EMC_USE_WATCHDOG 0
(ESP32 only)
**Experimental**
You can enable a watchdog on the MQTT task. This is experimental and will probably result in resets because some (framework) function calls block without feeding the dog.
### Logging
If needed, you have to enable logging at compile time. This is done differently on ESP32 and ESP8266.
ESP8266:
- Enable logging for Arduino [see docs](https://arduino-esp8266.readthedocs.io/en/latest/Troubleshooting/debugging.html)
- Pass the `DEBUG_ESP_MQTT_CLIENT` flag to the compiler
ESP32
- Enable logging for Arduino [see docs](https://docs.espressif.com/projects/arduino-esp32/en/latest/guides/tools_menu.html?#core-debug-level)
# Code samples
A number of examples are in the [examples](/examples) directory. These include basic operation on ESP8266 and ESP32. Please examine these to understand the basic operation of the MQTT client.
Below are examples on specific points for working with this library.
### Printing payloads
MQTT 3.1.1 defines no special format for the payload so it is treated as binary. If you want to print a payload to the Arduino serial console, you have to make sure that the payload is null-terminated (c-string).
```cpp
// option one: print the payload char by char
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received:");
Serial.printf(" topic: %s\n payload:", topic);
const char* p = reinterpret_cast<const char*>(payload);
for (size_t i = 0; i < len; ++i) {
Serial.print(p[i]);
}
Serial.print("\n");
}
```
```cpp
// option two: copy the payload into a c-string
// you cannot just do payload[len] = 0 because you do not own this memory location!
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received:");
Serial.printf(" topic: %s\n payload:", topic);
char* strval = new char[len + 1];
memcpy(strval, payload, len);
strval[len] = "\0";
Serial.println(strval);
delete[] strval;
}
```
### Assembling chunked messages
The `onMessage`-callback is called as data comes in. So if the data comes in partially, the callback will be called on every receipt of a chunk, with the proper `index`, (chunk)`size` and `total` set. With little code, you can reassemble chunked messages yourself.
```cpp
const size_t maxPayloadSize = 8192;
uint8_t* payloadbuffer = nullptr;
size_t payloadbufferSize = 0;
size_t payloadbufferIndex = 0;
void onOversizedMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
// handle oversized messages
}
void onCompleteMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
// handle assembled messages
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
// payload is bigger then max: return chunked
if (total > maxPayloadSize) {
onOversizedMqttMessage(properties, topic, payload, len, index, total);
return;
}
// start new packet, increase buffer size if neccesary
if (index == 0) {
if (total > payloadbufferSize) {
delete[] payloadbuffer;
payloadbufferSize = total;
payloadbuffer = new (std::nothrow) uint8_t[payloadbufferSize];
if (!payloadbuffer) {
// no buffer could be created. you might want to log this somewhere
return;
}
}
payloadbufferIndex = 0;
}
// add data and dispatch when done
if (payloadBuffer) {
memcpy(&payloadbuffer[payloadbufferIndex], payload, len);
payloadbufferIndex += len;
if (payloadbufferIndex == total) {
// message is complete here
onCompleteMqttMessage(properties, topic, payloadBuffer, total, 0, total);
// optionally:
delete[] payloadBuffer;
payloadBuffer = nullptr;
payloadbufferSize = 0;
}
}
}
// attach callback to MQTT client
mqttClient.onMessage(onMqttMessage);
```

BIN
lib/espMqttClient/docs/mqtt-v3.1.1.pdf Normal file
View File

Binary file not shown.

91
lib/espMqttClient/examples/largepayload-esp8266/largepayload-esp8266.ino Normal file
View File

@@ -0,0 +1,91 @@
#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <espMqttClient.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST IPAddress(192, 168, 1, 10)
#define MQTT_PORT 1883
WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
espMqttClient mqttClient;
Ticker reconnectTimer;
size_t fetchPayload(uint8_t* dest, size_t len, size_t index) {
Serial.printf("filling buffer at index %zu\n", index);
// fill the buffer with random bytes
// but maybe don't fill the entire buffer
size_t i = 0;
for (; i < len; ++i) {
dest[i] = random(0xFF);
if (dest[i] > 0xFC) {
++i; // extra increment to compensate 'break'
break;
}
}
return i;
}
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
Serial.println("Connected to Wi-Fi.");
connectToMqtt();
}
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
Serial.println("Disconnected from Wi-Fi.");
reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
reconnectTimer.once(5, connectToWiFi);
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
mqttClient.publish("topic/largepayload", 1, false, fetchPayload, 6000);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWiFi();
}
void loop() {
mqttClient.loop();
}

142
lib/espMqttClient/examples/ota-esp8266/ota-esp8266.ino Normal file
View File

@@ -0,0 +1,142 @@
#include <ESP8266WiFi.h>
#include <Updater.h>
#include <Ticker.h>
#include <espMqttClient.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST IPAddress(192, 168, 130, 10)
#define MQTT_PORT 1883
#define UPDATE_TOPIC "device/firmware/set"
WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
espMqttClient mqttClient;
Ticker reconnectTimer;
bool disconnectFlag = false;
bool restartFlag = false;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
Serial.println("Connected to Wi-Fi.");
connectToMqtt();
}
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
Serial.println("Disconnected from Wi-Fi.");
reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
reconnectTimer.once(5, connectToWiFi);
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub = mqttClient.subscribe(UPDATE_TOPIC, 2);
Serial.print("Subscribing at QoS 2, packetId: ");
Serial.println(packetIdSub);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (disconnectFlag) {
restartFlag = true;
return;
}
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void handleUpdate(const uint8_t* payload, size_t length, size_t index, size_t total) {
// The Updater class takes a non-const pointer to write data although it doesn't change the data
uint8_t* data = const_cast<uint8_t*>(payload);
static size_t written = 0;
Update.runAsync(true);
if (index == 0) {
if (Update.isRunning()) {
Update.end();
Update.clearError();
}
Update.begin(total);
written = Update.write(data, length);
Serial.printf("Updating %u/%u\n", written, Update.size());
} else {
if (!Update.isRunning()) return;
written += Update.write(data, length);
Serial.printf("Updating %u/%u\n", written, Update.size());
}
if (Update.isFinished()) {
if (Update.end()) {
Serial.println("Update succes");
disconnectFlag = true;
} else {
Serial.printf("Update error: %u\n", Update.getError());
Update.printError(Serial);
Update.clearError();
}
}
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
if (strcmp(UPDATE_TOPIC, topic) != 0) {
Serial.println("Topic mismatch");
return;
}
handleUpdate(payload, len, index, total);
}
void setup() {
Serial.begin(74880);
Serial.println();
Serial.println();
wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWiFi();
}
void loop() {
mqttClient.loop();
if (disconnectFlag) {
// it's safe to call this multiple times
mqttClient.disconnect();
}
if (restartFlag) {
Serial.println("Rebooting... See you next time!");
Serial.flush();
ESP.reset();
}
}

127
lib/espMqttClient/examples/simple-esp32/simple-esp32.ino Normal file
View File

@@ -0,0 +1,127 @@
#include <WiFi.h>
#include <Ticker.h>
#include <espMqttClient.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST IPAddress(192, 168, 1, 10)
#define MQTT_PORT 1883
espMqttClient mqttClient;
Ticker reconnectTimer;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d\n", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
connectToMqtt();
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
reconnectTimer.once(5, connectToWiFi);
break;
default:
break;
}
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub = mqttClient.subscribe("foo/bar", 2);
Serial.print("Subscribing at QoS 2, packetId: ");
Serial.println(packetIdSub);
mqttClient.publish("foo/bar", 0, true, "test 1");
Serial.println("Publishing at QoS 0");
uint16_t packetIdPub1 = mqttClient.publish("foo/bar", 1, true, "test 2");
Serial.print("Publishing at QoS 1, packetId: ");
Serial.println(packetIdPub1);
uint16_t packetIdPub2 = mqttClient.publish("foo/bar", 2, true, "test 3");
Serial.print("Publishing at QoS 2, packetId: ");
Serial.println(packetIdPub2);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void onMqttUnsubscribe(uint16_t packetId) {
Serial.println("Unsubscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received.");
Serial.print(" topic: ");
Serial.println(topic);
Serial.print(" qos: ");
Serial.println(properties.qos);
Serial.print(" dup: ");
Serial.println(properties.dup);
Serial.print(" retain: ");
Serial.println(properties.retain);
Serial.print(" len: ");
Serial.println(len);
Serial.print(" index: ");
Serial.println(index);
Serial.print(" total: ");
Serial.println(total);
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
WiFi.onEvent(WiFiEvent);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWiFi();
}
void loop() {
// nothing to do here
}

123
lib/espMqttClient/examples/simple-esp8266/simple-esp8266.ino Normal file
View File

@@ -0,0 +1,123 @@
#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <espMqttClient.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST IPAddress(192, 168, 1, 10)
#define MQTT_PORT 1883
WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
espMqttClient mqttClient;
Ticker reconnectTimer;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
Serial.println("Connected to Wi-Fi.");
connectToMqtt();
}
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
Serial.println("Disconnected from Wi-Fi.");
reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
reconnectTimer.once(5, connectToWiFi);
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
Serial.print("Subscribing at QoS 2, packetId: ");
Serial.println(packetIdSub);
mqttClient.publish("test/lol", 0, true, "test 1");
Serial.println("Publishing at QoS 0");
uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
Serial.print("Publishing at QoS 1, packetId: ");
Serial.println(packetIdPub1);
uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
Serial.print("Publishing at QoS 2, packetId: ");
Serial.println(packetIdPub2);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void onMqttUnsubscribe(uint16_t packetId) {
Serial.println("Unsubscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received.");
Serial.print(" topic: ");
Serial.println(topic);
Serial.print(" qos: ");
Serial.println(properties.qos);
Serial.print(" dup: ");
Serial.println(properties.dup);
Serial.print(" retain: ");
Serial.println(properties.retain);
Serial.print(" len: ");
Serial.println(len);
Serial.print(" index: ");
Serial.println(index);
Serial.print(" total: ");
Serial.println(total);
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWiFi();
}
void loop() {
mqttClient.loop();
}

89
lib/espMqttClient/examples/simple-linux/main.cpp Normal file
View File

@@ -0,0 +1,89 @@
#include <iostream>
#include <thread>
#include <espMqttClient.h>
#define MQTT_HOST IPAddress(192,168,1,10)
#define MQTT_PORT 1883
espMqttClient mqttClient;
std::atomic_bool exitProgram(false);
void connectToMqtt() {
std::cout << "Connecting to MQTT..." << std::endl;
mqttClient.connect();
}
void onMqttConnect(bool sessionPresent) {
std::cout << "Connected to MQTT." << std::endl;
std::cout << "Session present: " << sessionPresent << std::endl;
uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
std::cout << "Subscribing at QoS 2, packetId: " << packetIdSub << std::endl;
mqttClient.publish("test/lol", 0, true, "test 1");
std::cout << "Publishing at QoS 0" << std::endl;
uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
std::cout << "Publishing at QoS 1, packetId: " << packetIdPub1 << std::endl;
uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
std::cout << "Publishing at QoS 2, packetId: " << packetIdPub2 << std::endl;
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
std::cout << "Disconnected from MQTT: %u.\n" << unsigned(static_cast<uint8_t>(reason)) << std::endl;
exitProgram = true;
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
std::cout << "Subscribe acknowledged." << std::endl;
std::cout << " packetId: " << packetId << std::endl;
for (size_t i = 0; i < len; ++i) {
std::cout << " qos: " << unsigned(static_cast<uint8_t>(codes[i])) << std::endl;
}
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
(void) payload;
std::cout << "Publish received." << std::endl;
std::cout << " topic: " << topic << std::endl;
std::cout << " qos: " << unsigned(properties.qos) << std::endl;
std::cout << " dup: " << properties.dup << std::endl;
std::cout << " retain: " << properties.retain << std::endl;
std::cout << " len: " << len << std::endl;
std::cout << " index: " << index << std::endl;
std::cout << " total: " << total << std::endl;
}
void onMqttPublish(uint16_t packetId) {
std::cout << "Publish acknowledged." << std::endl;
std::cout << " packetId: " << packetId << std::endl;
}
void ClientLoop(void* arg) {
(void) arg;
for(;;) {
mqttClient.loop(); // includes a yield
if (exitProgram) break;
}
}
int main() {
std::cout << "Setting up sample MQTT client" << std::endl;
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
std::cout << "Starting sample MQTT client" << std::endl;
std::thread t = std::thread(ClientLoop, nullptr);
connectToMqtt();
while(1) {
if (exitProgram) break;
std::this_thread::yield();
}
t.join();
return EXIT_SUCCESS;
}

28
lib/espMqttClient/examples/simple-linux/platformio.ini Normal file
View File

@@ -0,0 +1,28 @@
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
;[platformio]
;default_envs = esp8266
[common]
build_flags =
-D DEBUG_ESP_MQTT_CLIENT=1
-std=c++11
-pthread
-Wall
-Wextra
[env:native]
platform = native
build_flags =
${common.build_flags}
-D EMC_RX_BUFFER_SIZE=1500
build_type = debug
lib_compat_mode = off

127
lib/espMqttClient/examples/simpleAsync-esp32/simpleAsync-esp32.ino Normal file
View File

@@ -0,0 +1,127 @@
#include <WiFi.h>
#include <Ticker.h>
#include <espMqttClientAsync.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST IPAddress(192, 168, 1, 10)
#define MQTT_PORT 1883
espMqttClientAsync mqttClient;
Ticker reconnectTimer;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d\n", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
connectToMqtt();
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
reconnectTimer.once(5, connectToWiFi);
break;
default:
break;
}
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub = mqttClient.subscribe("foo/bar", 2);
Serial.print("Subscribing at QoS 2, packetId: ");
Serial.println(packetIdSub);
mqttClient.publish("foo/bar", 0, true, "test 1");
Serial.println("Publishing at QoS 0");
uint16_t packetIdPub1 = mqttClient.publish("foo/bar", 1, true, "test 2");
Serial.print("Publishing at QoS 1, packetId: ");
Serial.println(packetIdPub1);
uint16_t packetIdPub2 = mqttClient.publish("foo/bar", 2, true, "test 3");
Serial.print("Publishing at QoS 2, packetId: ");
Serial.println(packetIdPub2);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void onMqttUnsubscribe(uint16_t packetId) {
Serial.println("Unsubscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received.");
Serial.print(" topic: ");
Serial.println(topic);
Serial.print(" qos: ");
Serial.println(properties.qos);
Serial.print(" dup: ");
Serial.println(properties.dup);
Serial.print(" retain: ");
Serial.println(properties.retain);
Serial.print(" len: ");
Serial.println(len);
Serial.print(" index: ");
Serial.println(index);
Serial.print(" total: ");
Serial.println(total);
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
WiFi.onEvent(WiFiEvent);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWiFi();
}
void loop() {
// nothing to do here
}

123
lib/espMqttClient/examples/simpleAsync-esp8266/simpleAsync-esp8266.ino Normal file
View File

@@ -0,0 +1,123 @@
#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <espMqttClientAsync.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST IPAddress(192, 168, 1, 10)
#define MQTT_PORT 1883
WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
espMqttClientAsync mqttClient;
Ticker reconnectTimer;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
Serial.println("Connected to Wi-Fi.");
connectToMqtt();
}
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
Serial.println("Disconnected from Wi-Fi.");
reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
reconnectTimer.once(5, connectToWiFi);
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
Serial.print("Subscribing at QoS 2, packetId: ");
Serial.println(packetIdSub);
mqttClient.publish("test/lol", 0, true, "test 1");
Serial.println("Publishing at QoS 0");
uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
Serial.print("Publishing at QoS 1, packetId: ");
Serial.println(packetIdPub1);
uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
Serial.print("Publishing at QoS 2, packetId: ");
Serial.println(packetIdPub2);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void onMqttUnsubscribe(uint16_t packetId) {
Serial.println("Unsubscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received.");
Serial.print(" topic: ");
Serial.println(topic);
Serial.print(" qos: ");
Serial.println(properties.qos);
Serial.print(" dup: ");
Serial.println(properties.dup);
Serial.print(" retain: ");
Serial.println(properties.retain);
Serial.print(" len: ");
Serial.println(len);
Serial.print(" index: ");
Serial.println(index);
Serial.print(" total: ");
Serial.println(total);
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
connectToWiFi();
}
void loop() {
// nothing to do here
}

145
lib/espMqttClient/examples/tls-esp32/tls-esp32.ino Normal file
View File

@@ -0,0 +1,145 @@
#include <WiFi.h>
#include <Ticker.h>
#include <espMqttClient.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST "mqtt.yourhost.com"
#define MQTT_PORT 8883
#define MQTT_USER "username"
#define MQTT_PASS "password"
const char rootCA[] = \
"-----BEGIN CERTIFICATE-----\n" \
" add your certificate here \n" \
"-----END CERTIFICATE-----\n";
espMqttClientSecure mqttClient;
Ticker reconnectTimer;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d\n", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
connectToMqtt();
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
reconnectTimer.once(5, connectToWiFi);
break;
default:
break;
}
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub0 = mqttClient.subscribe("foo/bar/0", 0);
Serial.print("Subscribing at QoS 0, packetId: ");
Serial.println(packetIdSub0);
uint16_t packetIdPub0 = mqttClient.publish("foo/bar/0", 0, false, "test");
Serial.println("Publishing at QoS 0, packetId: ");
Serial.println(packetIdPub0);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void onMqttUnsubscribe(uint16_t packetId) {
Serial.println("Unsubscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received.");
Serial.print(" topic: ");
Serial.println(topic);
Serial.print(" qos: ");
Serial.println(properties.qos);
Serial.print(" dup: ");
Serial.println(properties.dup);
Serial.print(" retain: ");
Serial.println(properties.retain);
Serial.print(" len: ");
Serial.println(len);
Serial.print(" index: ");
Serial.println(index);
Serial.print(" total: ");
Serial.println(total);
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
WiFi.onEvent(WiFiEvent);
//mqttClient.setInsecure();
mqttClient.setCACert(rootCA);
mqttClient.setCredentials(MQTT_USER, MQTT_PASS);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
mqttClient.setCleanSession(true);
connectToWiFi();
}
void loop() {
static uint32_t lastMillis = 0;
if (millis() - lastMillis > 5000) {
lastMillis = millis();
Serial.printf("heap: %u\n", ESP.getFreeHeap());
}
static uint32_t millisDisconnect = 0;
if (millis() - millisDisconnect > 60000) {
millisDisconnect = millis();
mqttClient.disconnect();
}
}

127
lib/espMqttClient/examples/tls-esp8266/tls-esp8266.ino Normal file
View File

@@ -0,0 +1,127 @@
#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <espMqttClient.h>
#define WIFI_SSID "yourSSID"
#define WIFI_PASSWORD "yourpass"
#define MQTT_HOST "test.mosquitto.org"
#define MQTT_PORT 1883
// test.mosquitto.org
const uint8_t fingerprint[] = {0xee, 0xbc, 0x4b, 0xf8, 0x57, 0xe3, 0xd3, 0xe4, 0x07, 0x54, 0x23, 0x1e, 0xf0, 0xc8, 0xa1, 0x56, 0xe0, 0xd3, 0x1a, 0x1c};
WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
espMqttClientSecure mqttClient;
Ticker reconnectTimer;
void connectToWiFi() {
Serial.println("Connecting to Wi-Fi...");
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}
void connectToMqtt() {
Serial.println("Connecting to MQTT...");
mqttClient.connect();
}
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
Serial.println("Connected to Wi-Fi.");
connectToMqtt();
}
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
Serial.println("Disconnected from Wi-Fi.");
reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
reconnectTimer.once(5, connectToWiFi);
}
void onMqttConnect(bool sessionPresent) {
Serial.println("Connected to MQTT.");
Serial.print("Session present: ");
Serial.println(sessionPresent);
uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
Serial.print("Subscribing at QoS 2, packetId: ");
Serial.println(packetIdSub);
mqttClient.publish("test/lol", 0, true, "test 1");
Serial.println("Publishing at QoS 0");
uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
Serial.print("Publishing at QoS 1, packetId: ");
Serial.println(packetIdPub1);
uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
Serial.print("Publishing at QoS 2, packetId: ");
Serial.println(packetIdPub2);
}
void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
if (WiFi.isConnected()) {
reconnectTimer.once(5, connectToMqtt);
}
}
void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
Serial.println("Subscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
for (size_t i = 0; i < len; ++i) {
Serial.print(" qos: ");
Serial.println(static_cast<uint8_t>(codes[i]));
}
}
void onMqttUnsubscribe(uint16_t packetId) {
Serial.println("Unsubscribe acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
Serial.println("Publish received.");
Serial.print(" topic: ");
Serial.println(topic);
Serial.print(" qos: ");
Serial.println(properties.qos);
Serial.print(" dup: ");
Serial.println(properties.dup);
Serial.print(" retain: ");
Serial.println(properties.retain);
Serial.print(" len: ");
Serial.println(len);
Serial.print(" index: ");
Serial.println(index);
Serial.print(" total: ");
Serial.println(total);
}
void onMqttPublish(uint16_t packetId) {
Serial.println("Publish acknowledged.");
Serial.print(" packetId: ");
Serial.println(packetId);
}
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
mqttClient.onSubscribe(onMqttSubscribe);
mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onMessage(onMqttMessage);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
mqttClient.setFingerprint(fingerprint);
connectToWiFi();
}
void loop() {
mqttClient.loop();
}

60
lib/espMqttClient/keywords.txt Normal file
View File

@@ -0,0 +1,60 @@
# Datatypes (KEYWORD1)
espMqttClient KEYWORD1
espMqttClientSecure KEYWORD1
OnConnectCallback KEYWORD1
OnDisconnectCallback KEYWORD1
OnSubscribeCallback KEYWORD1
OnUnsubscribeCallback KEYWORD1
OnMessageCallback KEYWORD1
OnPublishCallback KEYWORD1
# Methods and Functions (KEYWORD2)
setKeepAlive KEYWORD2
setClientId KEYWORD2
setCleanSession KEYWORD2
setCredentials KEYWORD2
setWill KEYWORD2
setServer KEYWORD2
setInsecure KEYWORD2
setCACert KEYWORD2
setCertificate KEYWORD2
setPrivateKey KEYWORD2
setPreSharedKey KEYWORD2
setFingerprint KEYWORD2
setTrustAnchors KEYWORD2
setClientRSACert KEYWORD2
setClientECCert KEYWORD2
setCertStore KEYWORD2
onConnect KEYWORD2
onDisconnect KEYWORD2
onSubscribe KEYWORD2
onUnsubscribe KEYWORD2
onMessage KEYWORD2
onPublish KEYWORD2
connected KEYWORD2
connect KEYWORD2
disconnect KEYWORD2
subscribe KEYWORD2
unsubscribe KEYWORD2
publish KEYWORD2
clearQueue KEYWORD2
loop KEYWORD2
getClientId KEYWORD2
# Structures (KEYWORD3)
espMqttClientTypes KEYWORD3
MessageProperties KEYWORD3
DisconnectReason KEYWORD3
# Constants (LITERAL1)
TCP_DISCONNECTED LITERAL1
MQTT_UNACCEPTABLE_PROTOCOL_VERSION LITERAL1
MQTT_IDENTIFIER_REJECTED LITERAL1
MQTT_SERVER_UNAVAILABLE LITERAL1
MQTT_MALFORMED_CREDENTIALS LITERAL1
MQTT_NOT_AUTHORIZED LITERAL1
TLS_BAD_FINGERPRINT LITERAL1

37
lib/espMqttClient/library.json Normal file
View File

@@ -0,0 +1,37 @@
{
"name": "espMqttClient",
"keywords": "iot, home, automation, mqtt, client, esp8266, esp32",
"description": "an MQTT client for the Arduino framework for ESP8266 / ESP32",
"authors":
{
"name": "Bert Melis",
"url": "https://github.com/bertmelis"
},
"license": "MIT",
"homepage": "https://github.com/bertmelis/espMqttClient",
"repository":
{
"type": "git",
"url": "https://github.com/bertmelis/espMqttClient.git"
},
"version": "1.3.3",
"frameworks": "arduino",
"platforms": ["espressif8266", "espressif32"],
"headers": ["espMqttClient.h", "espMqttClientAsync.h"],
"dependencies": [
{
"name": "ESPAsyncTCP",
"version": ">=1.2.2",
"platforms": "espressif8266"
},
{
"name": "AsyncTCP",
"version": ">=1.1.1",
"platforms": "espressif32"
}
],
"build":
{
"libLDFMode": "deep+"
}
}

9
lib/espMqttClient/library.properties Normal file
View File

@@ -0,0 +1,9 @@
name=espMqttClient
version=1.3.3
author=Bert Melis
maintainer=Bert Melis
sentence=an MQTT client for the Arduino framework for ESP8266 / ESP32
paragraph=
category=Communication
url=https://github.com/bertmelis/espMqttClient
architectures=esp8266,esp32

33
lib/espMqttClient/platformio.ini Normal file
View File

@@ -0,0 +1,33 @@
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
;[platformio]
;default_envs = esp8266
[common]
build_flags =
-D DEBUG_ESP_MQTT_CLIENT=1
-D CORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_VERBOSE
-Wall
-Wextra
-std=c++11
-pthread
[env:native]
platform = native
test_build_src = yes
build_flags =
${common.build_flags}
-lgcov
--coverage
-D EMC_RX_BUFFER_SIZE=100
-D EMC_TX_BUFFER_SIZE=10
;extra_scripts = test-coverage.py
build_type = debug

50
lib/espMqttClient/scripts/CI/build_examples_pio.sh Normal file
View File

@@ -0,0 +1,50 @@
#!/bin/bash
# already done by workflow
#pip install -U platformio
#platformio update
#pio pkg install --global --library me-no-dev/AsyncTCP
#pio pkg install --global --library EspAsyncTCP
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m'
lines=$(find ./examples/ -maxdepth 1 -mindepth 1 -type d)
retval=0
retvalpart=0
while read line; do
if [[ "$line" != *esp8266 && "$line" != *esp32 && "$line" != *linux ]]; then
echo -e "========================== BUILDING $line =========================="
echo -e "${YELLOW}SKIPPING${NC}"
continue
fi
echo -e "========================== BUILDING $line =========================="
if [[ -e "$line/platformio.ini" ]]; then
output=$(platformio ci --lib="." --project-conf="$line/platformio.ini" $line 2>&1)
retvalpart=$?
else
if [[ "$line" == *esp8266 ]]; then
output=$(platformio ci --lib="." --project-conf="scripts/CI/platformio_esp8266.ini" $line 2>&1)
retvalpart=$?
else
output=$(platformio ci --lib="." --project-conf="scripts/CI/platformio_esp32.ini" $line 2>&1)
retvalpart=$?
fi
:
fi
if [ $retvalpart -ne 0 ]; then
echo "$output"
echo -e "Building $line ${RED}FAILED${NC}"
retval=1
else
echo -e "${GREEN}SUCCESS${NC}"
fi
done <<< "$lines"
# will be deleted together with container
#pio pkg uninstall --global --library me-no-dev/AsyncTCP
#pio pkg uninstall --global --library EspAsyncTCP
exit "$retval"

18
lib/espMqttClient/scripts/CI/platformio_esp32.ini Normal file
View File

@@ -0,0 +1,18 @@
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env:esp32]
platform = espressif32
board = lolin32
framework = arduino
build_flags =
;-Werror
-Wall
-Wextra

18
lib/espMqttClient/scripts/CI/platformio_esp8266.ini Normal file
View File

@@ -0,0 +1,18 @@
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env:esp8266]
platform = espressif8266
board = d1_mini
framework = arduino
build_flags =
;-Werror
-Wall
-Wextra

30
lib/espMqttClient/scripts/get-fingerprint.py Normal file
View File

@@ -0,0 +1,30 @@
#!/usr/bin/env python
# https://github.com/marvinroger/async-mqtt-client/blob/develop/scripts/get-fingerprint/get-fingerprint.py
import argparse
import ssl
import hashlib
parser = argparse.ArgumentParser(description='Compute SSL/TLS fingerprints.')
parser.add_argument('--host', required=True)
parser.add_argument('--port', default=8883)
args = parser.parse_args()
print(args.host)
cert_pem = ssl.get_server_certificate((args.host, args.port))
cert_der = ssl.PEM_cert_to_DER_cert(cert_pem)
md5 = hashlib.md5(cert_der).hexdigest()
sha1 = hashlib.sha1(cert_der).hexdigest()
sha256 = hashlib.sha256(cert_der).hexdigest()
print("MD5: " + md5)
print("SHA1: " + sha1)
print("SHA256: " + sha256)
print("\nSHA1 as array initializer:")
print("const uint8_t fingerprint[] = {0x" + ", 0x".join([sha1[i:i+2] for i in range(0, len(sha1), 2)]) + "};")
print("\nSHA1 as function call:")
print("mqttClient.addServerFingerprint((const uint8_t[]){0x" + ", 0x".join([sha1[i:i+2] for i in range(0, len(sha1), 2)]) + "});")

54
lib/espMqttClient/src/Config.h Normal file
View File

@@ -0,0 +1,54 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#ifndef EMC_TX_TIMEOUT
#define EMC_TX_TIMEOUT 5000
#endif
#ifndef EMC_RX_BUFFER_SIZE
#define EMC_RX_BUFFER_SIZE 1440
#endif
#ifndef EMC_TX_BUFFER_SIZE
#define EMC_TX_BUFFER_SIZE 1440
#endif
#ifndef EMC_MAX_TOPIC_LENGTH
#define EMC_MAX_TOPIC_LENGTH 128
#endif
#ifndef EMC_PAYLOAD_BUFFER_SIZE
#define EMC_PAYLOAD_BUFFER_SIZE 32
#endif
#ifndef EMC_MIN_FREE_MEMORY
#define EMC_MIN_FREE_MEMORY 4096
#endif
#ifndef EMC_ESP8266_MULTITHREADING
#define EMC_ESP8266_MULTITHREADING 0
#endif
#ifndef EMC_ALLOW_NOT_CONNECTED_PUBLISH
#define EMC_ALLOW_NOT_CONNECTED_PUBLISH 1
#endif
#ifndef EMC_CLIENTID_LENGTH
// esp8266abc123 and esp32abcdef123456
#define EMC_CLIENTID_LENGTH 23 + 1
#endif
#ifndef EMC_TASK_STACK_SIZE
#define EMC_TASK_STACK_SIZE 5000
#endif
#ifndef EMC_USE_WATCHDOG
#define EMC_USE_WATCHDOG 0
#endif

49
lib/espMqttClient/src/Helpers.h Normal file
View File

@@ -0,0 +1,49 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO_ARCH_ESP32)
#include <Arduino.h> // millis(), ESP.getFreeHeap();
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_task_wdt.h"
#define EMC_SEMAPHORE_TAKE() xSemaphoreTake(_xSemaphore, portMAX_DELAY)
#define EMC_SEMAPHORE_GIVE() xSemaphoreGive(_xSemaphore)
#define EMC_GET_FREE_MEMORY() std::max(ESP.getMaxAllocHeap(), ESP.getMaxAllocPsram())
#define EMC_YIELD() taskYIELD()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "esp32%06llx", ESP.getEfuseMac());
#elif defined(ARDUINO_ARCH_ESP8266)
#include <Arduino.h> // millis(), ESP.getFreeHeap();
#if EMC_ESP8266_MULTITHREADING
// This lib doesn't run use multithreading on ESP8266
// _xSemaphore defined as std::atomic<bool>
#define EMC_SEMAPHORE_TAKE() while (_xSemaphore) { /*ESP.wdtFeed();*/ } _xSemaphore = true
#define EMC_SEMAPHORE_GIVE() _xSemaphore = false
#else
#define EMC_SEMAPHORE_TAKE()
#define EMC_SEMAPHORE_GIVE()
#endif
#define EMC_GET_FREE_MEMORY() ESP.getMaxFreeBlockSize()
// no need to yield for ESP8266, the Arduino framework does this internally
// yielding in async is forbidden (will crash)
#define EMC_YIELD()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "esp8266%06x", ESP.getChipId());
#elif defined(__linux__)
#include <chrono> // NOLINT [build/c++11]
#include <thread> // NOLINT [build/c++11] for yield()
#define millis() std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count()
#define EMC_GET_FREE_MEMORY() 1000000000
#define EMC_YIELD() std::this_thread::yield()
#define EMC_GENERATE_CLIENTID(x) snprintf(x, EMC_CLIENTID_LENGTH, "Client%04d%04d%04d", rand()%10000, rand()%10000, rand()%10000)
#include <mutex> // NOLINT [build/c++11]
#define EMC_SEMAPHORE_TAKE() mtx.lock();
#define EMC_SEMAPHORE_GIVE() mtx.unlock();
#else
#error Target platform not supported
#endif

34
lib/espMqttClient/src/Logging.h Normal file
View File

@@ -0,0 +1,34 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO_ARCH_ESP32)
// Logging is en/disabled by Arduino framework macros
#include <esp32-hal-log.h>
#define emc_log_i(...) log_i(__VA_ARGS__)
#define emc_log_e(...) log_e(__VA_ARGS__)
#define emc_log_w(...) log_w(__VA_ARGS__)
#elif defined(ARDUINO_ARCH_ESP8266)
#if defined(DEBUG_ESP_PORT) && defined(DEBUG_ESP_MQTT_CLIENT)
#include <Arduino.h>
#define emc_log_i(...) DEBUG_ESP_PORT.printf(__VA_ARGS__); DEBUG_ESP_PORT.print("\n")
#define emc_log_e(...) DEBUG_ESP_PORT.printf(__VA_ARGS__); DEBUG_ESP_PORT.print("\n")
#define emc_log_w(...) DEBUG_ESP_PORT.printf(__VA_ARGS__); DEBUG_ESP_PORT.print("\n")
#else
#define emc_log_i(...)
#define emc_log_e(...)
#define emc_log_w(...)
#endif
#else
// when building for PC, always show debug statements as part of testing suite
#include <iostream>
#define emc_log_i(...) std::cout << "[I] " << __FILE__ ":" << __LINE__ << ": "; printf(__VA_ARGS__); std::cout << std::endl
#define emc_log_e(...) std::cout << "[E] " << __FILE__ ":" << __LINE__ << ": "; printf(__VA_ARGS__); std::cout << std::endl
#define emc_log_w(...) std::cout << "[W] " << __FILE__ ":" << __LINE__ << ": "; printf(__VA_ARGS__); std::cout << std::endl
#endif

669
lib/espMqttClient/src/MqttClient.cpp Normal file
View File

@@ -0,0 +1,669 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "MqttClient.h"
using espMqttClientInternals::Packet;
using espMqttClientInternals::PacketType;
using espMqttClientTypes::DisconnectReason;
using espMqttClientTypes::Error;
#if defined(ARDUINO_ARCH_ESP32)
MqttClient::MqttClient(bool useTask, uint8_t priority, uint8_t core)
: _useTask(useTask)
, _transport(nullptr)
#else
MqttClient::MqttClient()
: _transport(nullptr)
#endif
, _onConnectCallback(nullptr)
, _onDisconnectCallback(nullptr)
, _onSubscribeCallback(nullptr)
, _onUnsubscribeCallback(nullptr)
, _onMessageCallback(nullptr)
, _onPublishCallback(nullptr)
, _onErrorCallback(nullptr)
, _clientId(nullptr)
, _ip()
, _host(nullptr)
, _port(1183)
, _useIp(false)
, _keepAlive(15000)
, _cleanSession(true)
, _username(nullptr)
, _password(nullptr)
, _willTopic(nullptr)
, _willPayload(nullptr)
, _willPayloadLength(0)
, _willQos(0)
, _willRetain(false)
, _state(State::disconnected)
, _generatedClientId{0}
, _packetId(0)
#if defined(ARDUINO_ARCH_ESP32)
, _xSemaphore(nullptr)
, _taskHandle(nullptr)
#endif
, _rxBuffer{0}
, _outbox()
, _bytesSent(0)
, _parser()
, _lastClientActivity(0)
, _lastServerActivity(0)
, _pingSent(false)
, _disconnectReason(DisconnectReason::TCP_DISCONNECTED)
#if defined(ARDUINO_ARCH_ESP32)
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
, _highWaterMark(4294967295)
#endif
#endif
{
EMC_GENERATE_CLIENTID(_generatedClientId);
#if defined(ARDUINO_ARCH_ESP32)
_xSemaphore = xSemaphoreCreateMutex();
EMC_SEMAPHORE_GIVE(); // release before first use
if (useTask) {
xTaskCreatePinnedToCore((TaskFunction_t)_loop, "mqttclient", EMC_TASK_STACK_SIZE, this, priority, &_taskHandle, core);
}
#endif
_clientId = _generatedClientId;
}
MqttClient::~MqttClient() {
disconnect(true);
_clearQueue(true);
#if defined(ARDUINO_ARCH_ESP32)
vSemaphoreDelete(_xSemaphore);
if (_useTask) {
#if EMC_USE_WATCHDOG
esp_task_wdt_delete(_taskHandle); // not sure if this is really needed
#endif
vTaskDelete(_taskHandle);
}
#endif
}
bool MqttClient::connected() const {
if (_state == State::connected) return true;
return false;
}
bool MqttClient::disconnected() const {
if (_state == State::disconnected) return true;
return false;
}
bool MqttClient::connect() {
bool result = true;
if (_state == State::disconnected) {
EMC_SEMAPHORE_TAKE();
if (_addPacketFront(_cleanSession,
_username,
_password,
_willTopic,
_willRetain,
_willQos,
_willPayload,
_willPayloadLength,
(uint16_t)(_keepAlive / 1000), // 32b to 16b doesn't overflow because it comes from 16b orignally
_clientId)) {
#if defined(ARDUINO_ARCH_ESP32)
if (_useTask) {
vTaskResume(_taskHandle);
}
#endif
_state = State::connectingTcp1;
} else {
EMC_SEMAPHORE_GIVE();
emc_log_e("Could not create CONNECT packet");
_onError(0, Error::OUT_OF_MEMORY);
result = false;
}
EMC_SEMAPHORE_GIVE();
}
return result;
}
bool MqttClient::disconnect(bool force) {
if (force && _state != State::disconnected && _state != State::disconnectingTcp1 && _state != State::disconnectingTcp2) {
_state = State::disconnectingTcp1;
return true;
}
if (!force && _state == State::connected) {
_state = State::disconnectingMqtt1;
return true;
}
return false;
}
uint16_t MqttClient::publish(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) {
#if !EMC_ALLOW_NOT_CONNECTED_PUBLISH
if (_state != State::connected) {
return 0;
}
#endif
uint16_t packetId = (qos > 0) ? _getNextPacketId() : 1;
EMC_SEMAPHORE_TAKE();
if (!_addPacket(packetId, topic, payload, length, qos, retain)) {
emc_log_e("Could not create PUBLISH packet");
_onError(packetId, Error::OUT_OF_MEMORY);
packetId = 0;
}
EMC_SEMAPHORE_GIVE();
return packetId;
}
uint16_t MqttClient::publish(const char* topic, uint8_t qos, bool retain, const char* payload) {
size_t len = strlen(payload);
return publish(topic, qos, retain, reinterpret_cast<const uint8_t*>(payload), len);
}
uint16_t MqttClient::publish(const char* topic, uint8_t qos, bool retain, espMqttClientTypes::PayloadCallback callback, size_t length) {
#if !EMC_ALLOW_NOT_CONNECTED_PUBLISH
if (_state != State::connected) {
return 0;
}
#endif
uint16_t packetId = (qos > 0) ? _getNextPacketId() : 1;
EMC_SEMAPHORE_TAKE();
if (!_addPacket(packetId, topic, callback, length, qos, retain)) {
emc_log_e("Could not create PUBLISH packet");
_onError(packetId, Error::OUT_OF_MEMORY);
packetId = 0;
}
EMC_SEMAPHORE_GIVE();
return packetId;
}
void MqttClient::clearQueue(bool all) {
_clearQueue(all);
}
const char* MqttClient::getClientId() const {
return _clientId;
}
void MqttClient::loop() {
switch (_state) {
case State::disconnected:
#if defined(ARDUINO_ARCH_ESP32)
if (_useTask) {
vTaskSuspend(_taskHandle);
}
#endif
break;
case State::connectingTcp1:
if (_useIp ? _transport->connect(_ip, _port) : _transport->connect(_host, _port)) {
_state = State::connectingTcp2;
} else {
_state = State::disconnectingTcp1;
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
break;
}
// Falling through to speed up connecting on blocking transport 'connect' implementations
[[fallthrough]];
case State::connectingTcp2:
if (_transport->connected()) {
_parser.reset();
_lastClientActivity = _lastServerActivity = millis();
_state = State::connectingMqtt;
}
break;
case State::disconnectingMqtt1:
EMC_SEMAPHORE_TAKE();
if (_outbox.empty()) {
if (!_addPacket(PacketType.DISCONNECT)) {
EMC_SEMAPHORE_GIVE();
emc_log_e("Could not create DISCONNECT packet");
_onError(0, Error::OUT_OF_MEMORY);
} else {
_state = State::disconnectingMqtt2;
}
}
EMC_SEMAPHORE_GIVE();
// fall through to 'connected' to send out DISCONN packet
[[fallthrough]];
case State::disconnectingMqtt2:
[[fallthrough]];
case State::connectingMqtt:
// receipt of CONNACK packet will set state to CONNECTED
// client however is allowed to send packets before CONNACK is received
// so we fall through to 'connected'
[[fallthrough]];
case State::connected:
if (_transport->connected()) {
// CONNECT packet is first in the queue
_checkOutgoing();
_checkIncoming();
_checkPing();
} else {
_state = State::disconnectingTcp1;
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
}
break;
case State::disconnectingTcp1:
_transport->stop();
_state = State::disconnectingTcp2;
break;
case State::disconnectingTcp2:
if (_transport->disconnected()) {
_clearQueue(false);
_state = State::disconnected;
if (_onDisconnectCallback) _onDisconnectCallback(_disconnectReason);
}
break;
// all cases covered, no default case
}
EMC_YIELD();
#if defined(ARDUINO_ARCH_ESP32) && ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
size_t waterMark = uxTaskGetStackHighWaterMark(NULL);
if (waterMark < _highWaterMark) {
_highWaterMark = waterMark;
emc_log_i("Stack usage: %zu/%i", EMC_TASK_STACK_SIZE - _highWaterMark, EMC_TASK_STACK_SIZE);
}
#endif
}
#if defined(ARDUINO_ARCH_ESP32)
void MqttClient::_loop(MqttClient* c) {
#if EMC_USE_WATCHDOG
if (esp_task_wdt_add(NULL) != ESP_OK) {
emc_log_e("Failed to add async task to WDT");
}
#endif
for (;;) {
c->loop();
#if EMC_USE_WATCHDOG
esp_task_wdt_reset();
#endif
}
}
#endif
uint16_t MqttClient::_getNextPacketId() {
uint16_t packetId = 0;
EMC_SEMAPHORE_TAKE();
// cppcheck-suppress knownConditionTrueFalse
packetId = (++_packetId == 0) ? ++_packetId : _packetId;
EMC_SEMAPHORE_GIVE();
return packetId;
}
void MqttClient::_checkOutgoing() {
EMC_SEMAPHORE_TAKE();
Packet* packet = _outbox.getCurrent();
int32_t wantToWrite = 0;
int32_t written = 0;
while (packet && (wantToWrite == written)) {
// mixing signed with unsigned here but safe because of MQTT packet size limits
wantToWrite = packet->available(_bytesSent);
written = _transport->write(packet->data(_bytesSent), wantToWrite);
if (written < 0) {
emc_log_w("Write error, check connection");
break;
}
_lastClientActivity = millis();
_bytesSent += written;
emc_log_i("tx %zu/%zu (%02x)", _bytesSent, packet->size(), packet->packetType());
if (_bytesSent == packet->size()) {
if ((packet->packetType()) == PacketType.DISCONNECT) {
_state = State::disconnectingTcp1;
_disconnectReason = DisconnectReason::USER_OK;
}
if (packet->removable()) {
_outbox.removeCurrent();
} else {
// handle with care! millis() returns unsigned 32 bit, token is void*
packet->token = reinterpret_cast<void*>(millis());
if ((packet->packetType()) == PacketType.PUBLISH) packet->setDup();
_outbox.next();
}
packet = _outbox.getCurrent();
_bytesSent = 0;
}
}
EMC_SEMAPHORE_GIVE();
}
void MqttClient::_checkIncoming() {
int32_t remainingBufferLength = _transport->read(_rxBuffer, EMC_RX_BUFFER_SIZE);
if (remainingBufferLength > 0) {
_lastServerActivity = millis();
emc_log_i("rx len %i", remainingBufferLength);
size_t bytesParsed = 0;
size_t index = 0;
while (remainingBufferLength > 0) {
espMqttClientInternals::ParserResult result = _parser.parse(&_rxBuffer[index], remainingBufferLength, &bytesParsed);
if (result == espMqttClientInternals::ParserResult::packet) {
espMqttClientInternals::MQTTPacketType packetType = _parser.getPacket().fixedHeader.packetType & 0xF0;
if (_state == State::connectingMqtt && packetType != PacketType.CONNACK) {
emc_log_w("Disconnecting, expected CONNACK - protocol error");
_state = State::disconnectingTcp1;
return;
}
switch (packetType & 0xF0) {
case PacketType.CONNACK:
_onConnack();
if (_state != State::connected) {
return;
}
break;
case PacketType.PUBLISH:
if (_state == State::disconnectingMqtt1 || _state == State::disconnectingMqtt2) break; // stop processing incoming once user has called disconnect
_onPublish();
break;
case PacketType.PUBACK:
_onPuback();
break;
case PacketType.PUBREC:
_onPubrec();
break;
case PacketType.PUBREL:
_onPubrel();
break;
case PacketType.PUBCOMP:
_onPubcomp();
break;
case PacketType.SUBACK:
_onSuback();
break;
case PacketType.UNSUBACK:
_onUnsuback();
break;
case PacketType.PINGRESP:
_pingSent = false;
break;
}
} else if (result == espMqttClientInternals::ParserResult::protocolError) {
emc_log_w("Disconnecting, protocol error");
_state = State::disconnectingTcp1;
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
return;
}
remainingBufferLength -= bytesParsed;
index += bytesParsed;
emc_log_i("Parsed %zu - remaining %i", bytesParsed, remainingBufferLength);
bytesParsed = 0;
}
}
}
void MqttClient::_checkPing() {
if (_keepAlive == 0) return; // keepalive is disabled
uint32_t currentMillis = millis();
// disconnect when server was inactive for twice the keepalive time
if (currentMillis - _lastServerActivity > 2 * _keepAlive) {
emc_log_w("Disconnecting, server exceeded keepalive");
_state = State::disconnectingTcp1;
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
return;
}
// send ping when client was inactive during the keepalive time
// or when server hasn't responded within keepalive time (typically due to QOS 0)
if (!_pingSent &&
((currentMillis - _lastClientActivity > _keepAlive) ||
(currentMillis - _lastServerActivity > _keepAlive))) {
EMC_SEMAPHORE_TAKE();
if (!_addPacket(PacketType.PINGREQ)) {
EMC_SEMAPHORE_GIVE();
emc_log_e("Could not create PING packet");
return;
}
EMC_SEMAPHORE_GIVE();
_pingSent = true;
}
}
void MqttClient::_onConnack() {
if (_parser.getPacket().variableHeader.fixed.connackVarHeader.returnCode == 0x00) {
_pingSent = false; // reset after keepalive timeout disconnect
_state = State::connected;
if (_parser.getPacket().variableHeader.fixed.connackVarHeader.sessionPresent == 0) {
_clearQueue(true);
}
if (_onConnectCallback) {
_onConnectCallback(_parser.getPacket().variableHeader.fixed.connackVarHeader.sessionPresent);
}
} else {
_state = State::disconnectingTcp1;
// cast is safe because the parser already checked for a valid return code
_disconnectReason = static_cast<DisconnectReason>(_parser.getPacket().variableHeader.fixed.connackVarHeader.returnCode);
}
}
void MqttClient::_onPublish() {
espMqttClientInternals::IncomingPacket p = _parser.getPacket();
uint8_t qos = p.qos();
bool retain = p.retain();
bool dup = p.dup();
uint16_t packetId = p.variableHeader.fixed.packetId;
bool callback = true;
if (qos == 1) {
if (p.payload.index + p.payload.length == p.payload.total) {
EMC_SEMAPHORE_TAKE();
if (!_addPacket(PacketType.PUBACK, packetId)) {
emc_log_e("Could not create PUBACK packet");
}
EMC_SEMAPHORE_GIVE();
}
} else if (qos == 2) {
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
while (it) {
if ((it.get()->packetType()) == PacketType.PUBREC && it.get()->packetId() == packetId) {
callback = false;
emc_log_e("QoS2 packet previously delivered");
break;
}
++it;
}
if (p.payload.index + p.payload.length == p.payload.total) {
if (!_addPacket(PacketType.PUBREC, packetId)) {
emc_log_e("Could not create PUBREC packet");
}
}
EMC_SEMAPHORE_GIVE();
}
if (callback && _onMessageCallback) _onMessageCallback({qos, dup, retain, packetId},
p.variableHeader.topic,
p.payload.data,
p.payload.length,
p.payload.index,
p.payload.total);
}
void MqttClient::_onPuback() {
bool callback = false;
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
while (it) {
// PUBACKs come in the order PUBs are sent. So we only check the first PUB packet in outbox
// if it doesn't match the ID, return
if ((it.get()->packetType()) == PacketType.PUBLISH) {
if (it.get()->packetId() == idToMatch) {
callback = true;
_outbox.remove(it);
break;
}
emc_log_w("Received out of order PUBACK");
break;
}
++it;
}
EMC_SEMAPHORE_GIVE();
if (callback) {
if (_onPublishCallback) _onPublishCallback(idToMatch);
} else {
emc_log_w("No matching PUBLISH packet found");
}
}
void MqttClient::_onPubrec() {
bool success = false;
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
while (it) {
// PUBRECs come in the order PUBs are sent. So we only check the first PUB packet in outbox
// if it doesn't match the ID, return
if ((it.get()->packetType()) == PacketType.PUBLISH) {
if (it.get()->packetId() == idToMatch) {
if (!_addPacket(PacketType.PUBREL, idToMatch)) {
emc_log_e("Could not create PUBREL packet");
}
_outbox.remove(it);
success = true;
break;
}
emc_log_w("Received out of order PUBREC");
break;
}
++it;
}
if (!success) {
emc_log_w("No matching PUBLISH packet found");
}
EMC_SEMAPHORE_GIVE();
}
void MqttClient::_onPubrel() {
bool success = false;
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
while (it) {
// PUBRELs come in the order PUBRECs are sent. So we only check the first PUBREC packet in outbox
// if it doesn't match the ID, return
if ((it.get()->packetType()) == PacketType.PUBREC) {
if (it.get()->packetId() == idToMatch) {
if (!_addPacket(PacketType.PUBCOMP, idToMatch)) {
emc_log_e("Could not create PUBCOMP packet");
}
_outbox.remove(it);
success = true;
break;
}
emc_log_w("Received out of order PUBREL");
break;
}
++it;
}
if (!success) {
emc_log_w("No matching PUBREC packet found");
}
EMC_SEMAPHORE_GIVE();
}
void MqttClient::_onPubcomp() {
bool callback = false;
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
while (it) {
// PUBCOMPs come in the order PUBRELs are sent. So we only check the first PUBREL packet in outbox
// if it doesn't match the ID, return
if ((it.get()->packetType()) == PacketType.PUBREL) {
if (it.get()->packetId() == idToMatch) {
if (!_addPacket(PacketType.PUBCOMP, idToMatch)) {
emc_log_e("Could not create PUBCOMP packet");
}
callback = true;
_outbox.remove(it);
break;
}
emc_log_w("Received out of order PUBCOMP");
break;
}
++it;
}
EMC_SEMAPHORE_GIVE();
if (callback) {
if (_onPublishCallback) _onPublishCallback(idToMatch);
} else {
emc_log_w("No matching PUBREL packet found");
}
}
void MqttClient::_onSuback() {
bool callback = false;
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
while (it) {
if (((it.get()->packetType()) == PacketType.SUBSCRIBE) && it.get()->packetId() == idToMatch) {
callback = true;
_outbox.remove(it);
break;
}
++it;
}
EMC_SEMAPHORE_GIVE();
if (callback) {
if (_onSubscribeCallback) _onSubscribeCallback(idToMatch, reinterpret_cast<const espMqttClientTypes::SubscribeReturncode*>(_parser.getPacket().payload.data), _parser.getPacket().payload.total);
} else {
emc_log_w("received SUBACK without SUB");
}
}
void MqttClient::_onUnsuback() {
bool callback = false;
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
while (it) {
if (it.get()->packetId() == idToMatch) {
callback = true;
_outbox.remove(it);
break;
}
++it;
}
EMC_SEMAPHORE_GIVE();
if (callback) {
if (_onUnsubscribeCallback) _onUnsubscribeCallback(idToMatch);
} else {
emc_log_w("received UNSUBACK without UNSUB");
}
}
void MqttClient::_clearQueue(bool clearSession) {
emc_log_i("clearing queue (clear session: %s)", clearSession ? "true" : "false");
EMC_SEMAPHORE_TAKE();
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.front();
if (clearSession) {
while (it) {
_outbox.remove(it);
}
} else {
// keep PUB (qos > 0, aka packetID != 0), PUBREC and PUBREL
// Spec only mentions PUB and PUBREL but this lib implements method B from point 4.3.3 (Fig. 4.3)
// and stores the packet id in the PUBREC packet. So we also must keep PUBREC.
while (it) {
espMqttClientInternals::MQTTPacketType type = it.get()->packetType();
if (type == PacketType.PUBREC ||
type == PacketType.PUBREL ||
(type == PacketType.PUBLISH && it.get()->packetId() != 0)) {
++it;
} else {
_outbox.remove(it);
}
}
}
EMC_SEMAPHORE_GIVE();
}
void MqttClient::_onError(uint16_t packetId, espMqttClientTypes::Error error) {
if (_onErrorCallback) {
_onErrorCallback(packetId, error);
}
}

185
lib/espMqttClient/src/MqttClient.h Normal file
View File

@@ -0,0 +1,185 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
API is based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <atomic>
#include <utility>
#include "Helpers.h"
#include "Config.h"
#include "TypeDefs.h"
#include "Logging.h"
#include "Outbox.h"
#include "Packets/Packet.h"
#include "Packets/Parser.h"
#include "Transport/Transport.h"
class MqttClient {
public:
virtual ~MqttClient();
bool connected() const;
bool disconnected() const;
bool connect();
bool disconnect(bool force = false);
template <typename... Args>
uint16_t subscribe(const char* topic, uint8_t qos, Args&&... args) {
uint16_t packetId = _getNextPacketId();
if (_state != State::connected) {
packetId = 0;
} else {
EMC_SEMAPHORE_TAKE();
if (!_addPacket(packetId, topic, qos, std::forward<Args>(args) ...)) {
emc_log_e("Could not create SUBSCRIBE packet");
packetId = 0;
}
EMC_SEMAPHORE_GIVE();
}
return packetId;
}
template <typename... Args>
uint16_t unsubscribe(const char* topic, Args&&... args) {
uint16_t packetId = _getNextPacketId();
if (_state != State::connected) {
packetId = 0;
} else {
EMC_SEMAPHORE_TAKE();
if (!_addPacket(packetId, topic, std::forward<Args>(args) ...)) {
emc_log_e("Could not create UNSUBSCRIBE packet");
packetId = 0;
}
EMC_SEMAPHORE_GIVE();
}
return packetId;
}
uint16_t publish(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length);
uint16_t publish(const char* topic, uint8_t qos, bool retain, const char* payload);
uint16_t publish(const char* topic, uint8_t qos, bool retain, espMqttClientTypes::PayloadCallback callback, size_t length);
void clearQueue(bool all = false); // Not MQTT compliant and may cause unpredictable results when `all` = true!
const char* getClientId() const;
#if defined(ARDUINO_ARCH_ESP32)
protected:
#endif
void loop();
#if defined(ARDUINO_ARCH_ESP32)
explicit MqttClient(bool useTask, uint8_t priority = 1, uint8_t core = 1);
bool _useTask;
#else
protected:
MqttClient();
#endif
espMqttClientInternals::Transport* _transport;
espMqttClientTypes::OnConnectCallback _onConnectCallback;
espMqttClientTypes::OnDisconnectCallback _onDisconnectCallback;
espMqttClientTypes::OnSubscribeCallback _onSubscribeCallback;
espMqttClientTypes::OnUnsubscribeCallback _onUnsubscribeCallback;
espMqttClientTypes::OnMessageCallback _onMessageCallback;
espMqttClientTypes::OnPublishCallback _onPublishCallback;
espMqttClientTypes::OnErrorCallback _onErrorCallback;
typedef void(*mqttClientHook)(void*);
const char* _clientId;
IPAddress _ip;
const char* _host;
uint16_t _port;
bool _useIp;
uint32_t _keepAlive;
bool _cleanSession;
const char* _username;
const char* _password;
const char* _willTopic;
const uint8_t* _willPayload;
uint16_t _willPayloadLength;
uint8_t _willQos;
bool _willRetain;
// state is protected to allow state changes by the transport system, defined in child classes
// eg. to allow AsyncTCP
enum class State {
disconnected,
connectingTcp1,
connectingTcp2,
connectingMqtt,
connected,
disconnectingMqtt1,
disconnectingMqtt2,
disconnectingTcp1,
disconnectingTcp2
};
std::atomic<State> _state;
private:
char _generatedClientId[EMC_CLIENTID_LENGTH];
uint16_t _packetId;
#if defined(ARDUINO_ARCH_ESP32)
SemaphoreHandle_t _xSemaphore;
TaskHandle_t _taskHandle;
static void _loop(MqttClient* c);
#elif defined(ARDUINO_ARCH_ESP8266) && EMC_ESP8266_MULTITHREADING
std::atomic<bool> _xSemaphore = false;
#elif defined(__linux__)
std::mutex mtx;
#endif
uint8_t _rxBuffer[EMC_RX_BUFFER_SIZE];
espMqttClientInternals::Outbox<espMqttClientInternals::Packet> _outbox;
size_t _bytesSent;
espMqttClientInternals::Parser _parser;
uint32_t _lastClientActivity;
uint32_t _lastServerActivity;
bool _pingSent;
espMqttClientTypes::DisconnectReason _disconnectReason;
uint16_t _getNextPacketId();
template <typename... Args>
bool _addPacket(Args&&... args) {
espMqttClientTypes::Error error;
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.emplace(error, std::forward<Args>(args) ...);
if (it && error == espMqttClientTypes::Error::SUCCESS) return true;
_outbox.remove(it);
return false;
}
template <typename... Args>
bool _addPacketFront(Args&&... args) {
espMqttClientTypes::Error error;
espMqttClientInternals::Outbox<espMqttClientInternals::Packet>::Iterator it = _outbox.emplaceFront(error, std::forward<Args>(args) ...);
if (it && error == espMqttClientTypes::Error::SUCCESS) return true;
_outbox.remove(it);
return false;
}
void _checkOutgoing();
void _checkIncoming();
void _checkPing();
void _onConnack();
void _onPublish();
void _onPuback();
void _onPubrec();
void _onPubrel();
void _onPubcomp();
void _onSuback();
void _onUnsuback();
void _clearQueue(bool clearSession);
void _onError(uint16_t packetId, espMqttClientTypes::Error error);
#if defined(ARDUINO_ARCH_ESP32)
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
size_t _highWaterMark;
#endif
#endif
};

115
lib/espMqttClient/src/MqttClientSetup.h Normal file
View File

@@ -0,0 +1,115 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
API is based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include "MqttClient.h"
class MqttClientSetup : public MqttClient {
public:
void setKeepAlive(uint16_t keepAlive) {
_keepAlive = keepAlive * 1000; // s to ms conversion, will also do 16 to 32 bit conversion
}
void setClientId(const char* clientId) {
_clientId = clientId;
}
void setCleanSession(bool cleanSession) {
_cleanSession = cleanSession;
}
void setCredentials(const char* username, const char* password) {
_username = username;
_password = password;
}
void setWill(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) {
_willTopic = topic;
_willQos = qos;
_willRetain = retain;
_willPayload = payload;
if (!_willPayload) {
_willPayloadLength = 0;
} else {
_willPayloadLength = length;
}
}
void setWill(const char* topic, uint8_t qos, bool retain, const char* payload) {
return setWill(topic, qos, retain, reinterpret_cast<const uint8_t*>(payload), strlen(payload));
}
void setServer(IPAddress ip, uint16_t port) {
_ip = ip;
_port = port;
_useIp = true;
}
void setServer(const char* host, uint16_t port) {
_host = host;
_port = port;
_useIp = false;
}
void onConnect(espMqttClientTypes::OnConnectCallback callback) {
_onConnectCallback = callback;
}
void onDisconnect(espMqttClientTypes::OnDisconnectCallback callback) {
_onDisconnectCallback = callback;
}
void onSubscribe(espMqttClientTypes::OnSubscribeCallback callback) {
_onSubscribeCallback = callback;
}
void onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback) {
_onUnsubscribeCallback = callback;
}
void onMessage(espMqttClientTypes::OnMessageCallback callback) {
_onMessageCallback = callback;
}
void onPublish(espMqttClientTypes::OnPublishCallback callback) {
_onPublishCallback = callback;
}
/*
void onError(espMqttClientTypes::OnErrorCallback callback) {
_onErrorCallback = callback;
}
*/
protected:
#if defined(ESP32)
explicit MqttClientSetup(bool useTask, uint8_t priority = 1, uint8_t core = 1)
: MqttClient(useTask, priority, core) {}
#else
MqttClientSetup()
: MqttClient() {}
#endif
};

202
lib/espMqttClient/src/Outbox.h Normal file
View File

@@ -0,0 +1,202 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <new> // new (std::nothrow)
#include <utility> // std::forward
namespace espMqttClientInternals {
/**
* @brief Singly linked queue with builtin non-invalidating forward iterator
*
* Queue items can only be emplaced, at front and back of the queue.
* Remove items using an iterator or the builtin iterator.
*/
template <typename T>
class Outbox {
public:
Outbox()
: _first(nullptr)
, _last(nullptr)
, _current(nullptr)
, _prev(nullptr) {}
~Outbox() {
while (_first) {
Node* n = _first->next;
delete _first;
_first = n;
}
}
struct Node {
public:
template <typename... Args>
explicit Node(Args&&... args)
: data(std::forward<Args>(args) ...)
, next(nullptr) {
// empty
}
T data;
Node* next;
};
class Iterator {
friend class Outbox;
public:
void operator++() {
if (_node) {
_prev = _node;
_node = _node->next;
}
}
explicit operator bool() const {
if (_node) return true;
return false;
}
T* get() const {
if (_node) return &(_node->data);
return nullptr;
}
private:
Node* _node = nullptr;
Node* _prev = nullptr;
};
// add node to back, advance current to new if applicable
template <class... Args>
Iterator emplace(Args&&... args) {
Iterator it;
Node* node = new (std::nothrow) Node(std::forward<Args>(args) ...);
if (node != nullptr) {
if (!_first) {
// queue is empty
_first = _current = node;
} else {
// queue has at least one item
_last->next = node;
it._prev = _last;
}
_last = node;
it._node = node;
// point current to newly created if applicable
if (!_current) {
_current = _last;
}
}
return it;
}
// add item to front, current points to newly created front.
template <class... Args>
Iterator emplaceFront(Args&&... args) {
Iterator it;
Node* node = new (std::nothrow) Node(std::forward<Args>(args) ...);
if (node != nullptr) {
if (!_first) {
// queue is empty
_last = node;
} else {
// queue has at least one item
node->next = _first;
}
_current = _first = node;
_prev = nullptr;
it._node = node;
}
return it;
}
// remove node at iterator, iterator points to next
void remove(Iterator& it) { // NOLINT(runtime/references)
Node* node = it._node;
Node* prev = it._prev;
++it;
_remove(prev, node);
}
// remove current node, current points to next
void removeCurrent() {
_remove(_prev, _current);
}
// Get current item or return nullptr
T* getCurrent() const {
if (_current) return &(_current->data);
return nullptr;
}
Iterator front() const {
Iterator it;
it._node = _first;
return it;
}
// Advance current item
void next() {
if (_current) {
_prev = _current;
_current = _current->next;
}
}
// Outbox is empty
bool empty() {
if (!_first) return true;
return false;
}
private:
Node* _first;
Node* _last;
Node* _current;
Node* _prev; // element just before _current
void _remove(Node* prev, Node* node) {
if (!node) return;
// set current to next, node->next may be nullptr
if (_current == node) {
_current = node->next;
}
if (_prev == node) {
_prev = prev;
}
// only one element in outbox
if (_first == _last) {
_first = _last = nullptr;
// delete first el in longer outbox
} else if (_first == node) {
_first = node->next;
// delete last in longer outbox
} else if (_last == node) {
_last = prev;
_last->next = nullptr;
// delete somewhere in the middle
} else {
prev->next = node->next;
}
// finally, delete the node
delete node;
}
};
} // end namespace espMqttClientInternals

77
lib/espMqttClient/src/Packets/Constants.h Normal file
View File

@@ -0,0 +1,77 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
Parts are based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stdint.h>
namespace espMqttClientInternals {
constexpr const char PROTOCOL[] = "MQTT";
constexpr const uint8_t PROTOCOL_LEVEL = 0b00000100;
typedef uint8_t MQTTPacketType;
constexpr struct {
const uint8_t RESERVED1 = 0;
const uint8_t CONNECT = 1 << 4;
const uint8_t CONNACK = 2 << 4;
const uint8_t PUBLISH = 3 << 4;
const uint8_t PUBACK = 4 << 4;
const uint8_t PUBREC = 5 << 4;
const uint8_t PUBREL = 6 << 4;
const uint8_t PUBCOMP = 7 << 4;
const uint8_t SUBSCRIBE = 8 << 4;
const uint8_t SUBACK = 9 << 4;
const uint8_t UNSUBSCRIBE = 10 << 4;
const uint8_t UNSUBACK = 11 << 4;
const uint8_t PINGREQ = 12 << 4;
const uint8_t PINGRESP = 13 << 4;
const uint8_t DISCONNECT = 14 << 4;
const uint8_t RESERVED2 = 1 << 4;
} PacketType;
constexpr struct {
const uint8_t CONNECT_RESERVED = 0x00;
const uint8_t CONNACK_RESERVED = 0x00;
const uint8_t PUBLISH_DUP = 0x08;
const uint8_t PUBLISH_QOS0 = 0x00;
const uint8_t PUBLISH_QOS1 = 0x02;
const uint8_t PUBLISH_QOS2 = 0x04;
const uint8_t PUBLISH_QOSRESERVED = 0x06;
const uint8_t PUBLISH_RETAIN = 0x01;
const uint8_t PUBACK_RESERVED = 0x00;
const uint8_t PUBREC_RESERVED = 0x00;
const uint8_t PUBREL_RESERVED = 0x02;
const uint8_t PUBCOMP_RESERVED = 0x00;
const uint8_t SUBSCRIBE_RESERVED = 0x02;
const uint8_t SUBACK_RESERVED = 0x00;
const uint8_t UNSUBSCRIBE_RESERVED = 0x02;
const uint8_t UNSUBACK_RESERVED = 0x00;
const uint8_t PINGREQ_RESERVED = 0x00;
const uint8_t PINGRESP_RESERVED = 0x00;
const uint8_t DISCONNECT_RESERVED = 0x00;
const uint8_t RESERVED2_RESERVED = 0x00;
} HeaderFlag;
constexpr struct {
const uint8_t USERNAME = 0x80;
const uint8_t PASSWORD = 0x40;
const uint8_t WILL_RETAIN = 0x20;
const uint8_t WILL_QOS0 = 0x00;
const uint8_t WILL_QOS1 = 0x08;
const uint8_t WILL_QOS2 = 0x10;
const uint8_t WILL = 0x04;
const uint8_t CLEAN_SESSION = 0x02;
const uint8_t RESERVED = 0x00;
} ConnectFlag;
} // end namespace espMqttClientInternals

445
lib/espMqttClient/src/Packets/Packet.cpp Normal file
View File

@@ -0,0 +1,445 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "Packet.h"
namespace espMqttClientInternals {
Packet::~Packet() {
free(_data);
}
size_t Packet::available(size_t index) {
if (index >= _size) return 0;
if (!_getPayload) return _size - index;
return _chunkedAvailable(index);
}
const uint8_t* Packet::data(size_t index) const {
if (!_getPayload) {
if (!_data) return nullptr;
if (index >= _size) return nullptr;
return &_data[index];
}
return _chunkedData(index);
}
size_t Packet::size() const {
return _size;
}
void Packet::setDup() {
if (!_data) return;
if (packetType() != PacketType.PUBLISH) return;
if (_packetId == 0) return;
_data[0] |= 0x08;
}
uint16_t Packet::packetId() const {
return _packetId;
}
MQTTPacketType Packet::packetType() const {
if (_data) return static_cast<MQTTPacketType>(_data[0] & 0xF0);
return static_cast<MQTTPacketType>(0);
}
bool Packet::removable() const {
if (_packetId == 0) return true;
if ((packetType() == PacketType.PUBACK) || (packetType() == PacketType.PUBCOMP)) return true;
return false;
}
Packet::Packet(espMqttClientTypes::Error& error,
bool cleanSession,
const char* username,
const char* password,
const char* willTopic,
bool willRetain,
uint8_t willQos,
const uint8_t* willPayload,
uint16_t willPayloadLength,
uint16_t keepAlive,
const char* clientId)
: token(nullptr)
, _packetId(0)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
if (willPayload && willPayloadLength == 0) {
size_t length = strlen(reinterpret_cast<const char*>(willPayload));
if (length > UINT16_MAX) {
emc_log_w("Payload length truncated (l:%zu)", length);
willPayloadLength = UINT16_MAX;
} else {
willPayloadLength = length;
}
}
if (!clientId || strlen(clientId) == 0) {
emc_log_w("clientId not set error");
error = espMqttClientTypes::Error::MALFORMED_PARAMETER;
return;
}
// Calculate size
size_t remainingLength =
6 + // protocol
1 + // protocol level
1 + // connect flags
2 + // keepalive
2 + strlen(clientId) +
(willTopic ? 2 + strlen(willTopic) + 2 + willPayloadLength : 0) +
(username ? 2 + strlen(username) : 0) +
(password ? 2 + strlen(password) : 0);
// allocate memory
if (!_allocate(remainingLength)) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
// serialize
size_t pos = 0;
// FIXED HEADER
_data[pos++] = PacketType.CONNECT | HeaderFlag.CONNECT_RESERVED;
pos += encodeRemainingLength(remainingLength, &_data[pos]);
pos += encodeString(PROTOCOL, &_data[pos]);
_data[pos++] = PROTOCOL_LEVEL;
uint8_t connectFlags = 0;
if (cleanSession) connectFlags |= espMqttClientInternals::ConnectFlag.CLEAN_SESSION;
if (username != nullptr) connectFlags |= espMqttClientInternals::ConnectFlag.USERNAME;
if (password != nullptr) connectFlags |= espMqttClientInternals::ConnectFlag.PASSWORD;
if (willTopic != nullptr) {
connectFlags |= espMqttClientInternals::ConnectFlag.WILL;
if (willRetain) connectFlags |= espMqttClientInternals::ConnectFlag.WILL_RETAIN;
switch (willQos) {
case 0:
connectFlags |= espMqttClientInternals::ConnectFlag.WILL_QOS0;
break;
case 1:
connectFlags |= espMqttClientInternals::ConnectFlag.WILL_QOS1;
break;
case 2:
connectFlags |= espMqttClientInternals::ConnectFlag.WILL_QOS2;
break;
}
}
_data[pos++] = connectFlags;
_data[pos++] = keepAlive >> 8;
_data[pos++] = keepAlive & 0xFF;
// PAYLOAD
// client ID
pos += encodeString(clientId, &_data[pos]);
// will
if (willTopic != nullptr && willPayload != nullptr) {
pos += encodeString(willTopic, &_data[pos]);
_data[pos++] = willPayloadLength >> 8;
_data[pos++] = willPayloadLength & 0xFF;
memcpy(&_data[pos], willPayload, willPayloadLength);
pos += willPayloadLength;
}
// credentials
if (username != nullptr) pos += encodeString(username, &_data[pos]);
if (password != nullptr) encodeString(password, &_data[pos]);
error = espMqttClientTypes::Error::SUCCESS;
}
Packet::Packet(espMqttClientTypes::Error& error,
uint16_t packetId,
const char* topic,
const uint8_t* payload,
size_t payloadLength,
uint8_t qos,
bool retain)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
size_t remainingLength =
2 + strlen(topic) + // topic length + topic
2 + // packet ID
payloadLength;
if (qos == 0) {
remainingLength -= 2;
_packetId = 0;
}
if (!_allocate(remainingLength)) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
size_t pos = _fillPublishHeader(packetId, topic, remainingLength, qos, retain);
// PAYLOAD
memcpy(&_data[pos], payload, payloadLength);
error = espMqttClientTypes::Error::SUCCESS;
}
Packet::Packet(espMqttClientTypes::Error& error,
uint16_t packetId,
const char* topic,
espMqttClientTypes::PayloadCallback payloadCallback,
size_t payloadLength,
uint8_t qos,
bool retain)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(payloadCallback) {
size_t remainingLength =
2 + strlen(topic) + // topic length + topic
2 + // packet ID
payloadLength;
if (qos == 0) {
remainingLength -= 2;
_packetId = 0;
}
if (!_allocate(remainingLength - payloadLength + std::min(payloadLength, static_cast<size_t>(EMC_RX_BUFFER_SIZE)))) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
size_t pos = _fillPublishHeader(packetId, topic, remainingLength, qos, retain);
// payload will be added by 'Packet::available'
_size = pos + payloadLength;
_payloadIndex = pos;
_payloadStartIndex = _payloadIndex;
_payloadEndIndex = _payloadIndex;
error = espMqttClientTypes::Error::SUCCESS;
}
Packet::Packet(espMqttClientTypes::Error& error, uint16_t packetId, const char* topic, uint8_t qos)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
SubscribeItem list[1] = {topic, qos};
_createSubscribe(error, list, 1);
}
Packet::Packet(espMqttClientTypes::Error& error, MQTTPacketType type, uint16_t packetId)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
if (!_allocate(2)) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
size_t pos = 0;
_data[pos] = type;
if (type == PacketType.PUBREL) {
_data[pos++] |= HeaderFlag.PUBREL_RESERVED;
} else {
pos++;
}
pos += encodeRemainingLength(2, &_data[pos]);
_data[pos++] = packetId >> 8;
_data[pos] = packetId & 0xFF;
error = espMqttClientTypes::Error::SUCCESS;
}
Packet::Packet(espMqttClientTypes::Error& error, uint16_t packetId, const char* topic)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
const char* list[1] = {topic};
_createUnsubscribe(error, list, 1);
}
Packet::Packet(espMqttClientTypes::Error& error, MQTTPacketType type)
: token(nullptr)
, _packetId(0)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
if (!_allocate(0)) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
_data[0] |= type;
error = espMqttClientTypes::Error::SUCCESS;
}
bool Packet::_allocate(size_t remainingLength) {
if (EMC_GET_FREE_MEMORY() < EMC_MIN_FREE_MEMORY) {
emc_log_w("Packet buffer not allocated: low memory");
return false;
}
_size = 1 + remainingLengthLength(remainingLength) + remainingLength;
_data = reinterpret_cast<uint8_t*>(malloc(_size));
if (!_data) {
_size = 0;
emc_log_w("Alloc failed (l:%zu)", _size);
return false;
}
emc_log_i("Alloc (l:%zu)", _size);
memset(_data, 0, _size);
return true;
}
size_t Packet::_fillPublishHeader(uint16_t packetId,
const char* topic,
size_t remainingLength,
uint8_t qos,
bool retain) {
size_t index = 0;
// FIXED HEADER
_data[index] = PacketType.PUBLISH;
if (retain) _data[index] |= HeaderFlag.PUBLISH_RETAIN;
if (qos == 0) {
_data[index++] |= HeaderFlag.PUBLISH_QOS0;
} else if (qos == 1) {
_data[index++] |= HeaderFlag.PUBLISH_QOS1;
} else if (qos == 2) {
_data[index++] |= HeaderFlag.PUBLISH_QOS2;
}
index += encodeRemainingLength(remainingLength, &_data[index]);
// VARIABLE HEADER
index += encodeString(topic, &_data[index]);
if (qos > 0) {
_data[index++] = packetId >> 8;
_data[index++] = packetId & 0xFF;
}
return index;
}
void Packet::_createSubscribe(espMqttClientTypes::Error& error,
SubscribeItem* list,
size_t numberTopics) {
// Calculate size
size_t payload = 0;
for (size_t i = 0; i < numberTopics; ++i) {
payload += 2 + strlen(list[i].topic) + 1; // length bytes, string, qos
}
size_t remainingLength = 2 + payload; // packetId + payload
// allocate memory
if (!_allocate(remainingLength)) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
// serialize
size_t pos = 0;
_data[pos++] = PacketType.SUBSCRIBE | HeaderFlag.SUBSCRIBE_RESERVED;
pos += encodeRemainingLength(remainingLength, &_data[pos]);
_data[pos++] = _packetId >> 8;
_data[pos++] = _packetId & 0xFF;
for (size_t i = 0; i < numberTopics; ++i) {
pos += encodeString(list[i].topic, &_data[pos]);
_data[pos++] = list[i].qos;
}
error = espMqttClientTypes::Error::SUCCESS;
}
void Packet::_createUnsubscribe(espMqttClientTypes::Error& error,
const char** list,
size_t numberTopics) {
// Calculate size
size_t payload = 0;
for (size_t i = 0; i < numberTopics; ++i) {
payload += 2 + strlen(list[i]); // length bytes, string
}
size_t remainingLength = 2 + payload; // packetId + payload
// allocate memory
if (!_allocate(remainingLength)) {
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
return;
}
// serialize
size_t pos = 0;
_data[pos++] = PacketType.UNSUBSCRIBE | HeaderFlag.UNSUBSCRIBE_RESERVED;
pos += encodeRemainingLength(remainingLength, &_data[pos]);
_data[pos++] = _packetId >> 8;
_data[pos++] = _packetId & 0xFF;
for (size_t i = 0; i < numberTopics; ++i) {
pos += encodeString(list[i], &_data[pos]);
}
error = espMqttClientTypes::Error::SUCCESS;
}
size_t Packet::_chunkedAvailable(size_t index) {
// index vs size check done in 'available(index)'
// index points to header or first payload byte
if (index < _payloadIndex) {
if (_size > _payloadIndex && _payloadEndIndex != 0) {
size_t copied = _getPayload(&_data[_payloadIndex], std::min(static_cast<size_t>(EMC_TX_BUFFER_SIZE), _size - _payloadStartIndex), index);
_payloadStartIndex = _payloadIndex;
_payloadEndIndex = _payloadStartIndex + copied - 1;
}
// index points to payload unavailable
} else if (index > _payloadEndIndex || _payloadStartIndex > index) {
_payloadStartIndex = index;
size_t copied = _getPayload(&_data[_payloadIndex], std::min(static_cast<size_t>(EMC_TX_BUFFER_SIZE), _size - _payloadStartIndex), index);
_payloadEndIndex = _payloadStartIndex + copied - 1;
}
// now index points to header or payload available
return _payloadEndIndex - index + 1;
}
const uint8_t* Packet::_chunkedData(size_t index) const {
// CAUTION!! available(index) has to be called first to check available data and possibly fill payloadbuffer
if (index < _payloadIndex) {
return &_data[index];
}
return &_data[index - _payloadStartIndex + _payloadIndex];
}
} // end namespace espMqttClientInternals

159
lib/espMqttClient/src/Packets/Packet.h Normal file
View File

@@ -0,0 +1,159 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stdint.h>
#include <stddef.h>
#include "Constants.h"
#include "Config.h"
#include "../TypeDefs.h"
#include "../Helpers.h"
#include "../Logging.h"
#include "RemainingLength.h"
#include "String.h"
namespace espMqttClientInternals {
class Packet {
public:
~Packet();
size_t available(size_t index);
const uint8_t* data(size_t index) const;
size_t size() const;
void setDup();
uint16_t packetId() const;
MQTTPacketType packetType() const;
bool removable() const;
void* token; // native typeless variable to store any additional data
protected:
uint16_t _packetId; // save as separate variable: will be accessed frequently
uint8_t* _data;
size_t _size;
// variables for chunked payload handling
size_t _payloadIndex;
size_t _payloadStartIndex;
size_t _payloadEndIndex;
espMqttClientTypes::PayloadCallback _getPayload;
struct SubscribeItem {
const char* topic;
uint8_t qos;
};
public:
// CONNECT
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
bool cleanSession,
const char* username,
const char* password,
const char* willTopic,
bool willRetain,
uint8_t willQos,
const uint8_t* willPayload,
uint16_t willPayloadLength,
uint16_t keepAlive,
const char* clientId);
// PUBLISH
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
uint16_t packetId,
const char* topic,
const uint8_t* payload,
size_t payloadLength,
uint8_t qos,
bool retain);
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
uint16_t packetId,
const char* topic,
espMqttClientTypes::PayloadCallback payloadCallback,
size_t payloadLength,
uint8_t qos,
bool retain);
// SUBSCRIBE
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
uint16_t packetId,
const char* topic,
uint8_t qos);
template<typename ... Args>
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
uint16_t packetId,
const char* topic1,
uint8_t qos1,
const char* topic2,
uint8_t qos2,
Args&& ... args)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
static_assert(sizeof...(Args) % 2 == 0);
size_t numberTopics = 2 + (sizeof...(Args) / 2);
SubscribeItem list[numberTopics] = {topic1, qos1, topic2, qos2, args...};
_createSubscribe(error, list, numberTopics);
}
// UNSUBSCRIBE
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
uint16_t packetId,
const char* topic);
template<typename ... Args>
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
uint16_t packetId,
const char* topic1,
const char* topic2,
Args&& ... args)
: token(nullptr)
, _packetId(packetId)
, _data(nullptr)
, _size(0)
, _payloadIndex(0)
, _payloadStartIndex(0)
, _payloadEndIndex(0)
, _getPayload(nullptr) {
size_t numberTopics = 2 + sizeof...(Args);
const char* list[numberTopics] = {topic1, topic2, args...};
_createUnsubscribe(error, list, numberTopics);
}
// PUBACK, PUBREC, PUBREL, PUBCOMP
Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
MQTTPacketType type,
uint16_t packetId);
// PING, DISCONN
explicit Packet(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
MQTTPacketType type);
private:
// pass remainingLength = total size - header - remainingLengthLength!
bool _allocate(size_t remainingLength);
// fills header and returns index of next available byte in buffer
size_t _fillPublishHeader(uint16_t packetId,
const char* topic,
size_t remainingLength,
uint8_t qos,
bool retain);
void _createSubscribe(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
SubscribeItem* list,
size_t numberTopics);
void _createUnsubscribe(espMqttClientTypes::Error& error, // NOLINT(runtime/references)
const char** list,
size_t numberTopics);
size_t _chunkedAvailable(size_t index);
const uint8_t* _chunkedData(size_t index) const;
};
} // end namespace espMqttClientInternals

316
lib/espMqttClient/src/Packets/Parser.cpp Normal file
View File

@@ -0,0 +1,316 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "Parser.h"
namespace espMqttClientInternals {
uint8_t IncomingPacket::qos() const {
if ((fixedHeader.packetType & 0xF0) != PacketType.PUBLISH) return 0;
return (fixedHeader.packetType & 0x06) >> 1; // mask 0x00000110
}
bool IncomingPacket::retain() const {
if ((fixedHeader.packetType & 0xF0) != PacketType.PUBLISH) return 0;
return fixedHeader.packetType & 0x01; // mask 0x00000001
}
bool IncomingPacket::dup() const {
if ((fixedHeader.packetType & 0xF0) != PacketType.PUBLISH) return 0;
return fixedHeader.packetType & 0x08; // mask 0x00001000
}
void IncomingPacket::reset() {
fixedHeader.packetType = 0;
variableHeader.topicLength = 0;
variableHeader.fixed.packetId = 0;
payload.index = 0;
payload.length = 0;
}
Parser::Parser()
: _data(nullptr)
, _len(0)
, _bytesRead(0)
, _bytePos(0)
, _parse(_fixedHeader)
, _packet()
, _payloadBuffer{0} {
// empty
}
ParserResult Parser::parse(const uint8_t* data, size_t len, size_t* bytesRead) {
_data = data;
_len = len;
_bytesRead = 0;
ParserResult result = ParserResult::awaitData;
while (result == ParserResult::awaitData && _bytesRead < _len) {
result = _parse(this);
++_bytesRead;
}
(*bytesRead) += _bytesRead;
return result;
}
const IncomingPacket& Parser::getPacket() const {
return _packet;
}
void Parser::reset() {
_parse = _fixedHeader;
_bytesRead = 0;
_bytePos = 0;
_packet.reset();
}
ParserResult Parser::_fixedHeader(Parser* p) {
p->_packet.reset();
p->_packet.fixedHeader.packetType = p->_data[p->_bytesRead];
// keep PUBLISH out of the switch and handle in separate if/else
if ((p->_packet.fixedHeader.packetType & 0xF0) == PacketType.PUBLISH) {
uint8_t headerFlags = p->_packet.fixedHeader.packetType & 0x0F;
/* flags can be: 0b0000 --> no dup, qos 0, no retain
0x0001 --> no dup, qos 0, retain
0x0010 --> no dup, qos 1, no retain
0x0011 --> no dup, qos 1, retain
0x0100 --> no dup, qos 2, no retain
0x0101 --> no dup, qos 2, retain
0x1010 --> dup, qos 1, no retain
0x1011 --> dup, qos 1, retain
0x1100 --> dup, qos 2, no retain
0x1101 --> dup, qos 2, retain
*/
if (headerFlags <= 0x05 || headerFlags >= 0x0A) {
p->_parse = _remainingLengthVariable;
p->_bytePos = 0;
} else {
emc_log_w("Invalid packet header: 0x%02x", p->_packet.fixedHeader.packetType);
return ParserResult::protocolError;
}
} else {
switch (p->_packet.fixedHeader.packetType) {
case PacketType.CONNACK | HeaderFlag.CONNACK_RESERVED:
case PacketType.PUBACK | HeaderFlag.PUBACK_RESERVED:
case PacketType.PUBREC | HeaderFlag.PUBREC_RESERVED:
case PacketType.PUBREL | HeaderFlag.PUBREL_RESERVED:
case PacketType.PUBCOMP | HeaderFlag.PUBCOMP_RESERVED:
case PacketType.UNSUBACK | HeaderFlag.UNSUBACK_RESERVED:
p->_parse = _remainingLengthFixed;
break;
case PacketType.SUBACK | HeaderFlag.SUBACK_RESERVED:
p->_parse = _remainingLengthVariable;
p->_bytePos = 0;
break;
case PacketType.PINGRESP | HeaderFlag.PINGRESP_RESERVED:
p->_parse = _remainingLengthNone;
break;
default:
emc_log_w("Invalid packet header: 0x%02x", p->_packet.fixedHeader.packetType);
return ParserResult::protocolError;
}
}
emc_log_i("Packet type: 0x%02x", p->_packet.fixedHeader.packetType);
return ParserResult::awaitData;
}
ParserResult Parser::_remainingLengthFixed(Parser* p) {
p->_packet.fixedHeader.remainingLength.remainingLength = p->_data[p->_bytesRead];
if (p->_packet.fixedHeader.remainingLength.remainingLength == 2) { // variable header is 2 bytes long
if ((p->_packet.fixedHeader.packetType & 0xF0) != PacketType.CONNACK) {
p->_parse = _varHeaderPacketId1;
} else {
p->_parse = _varHeaderConnack1;
}
emc_log_i("Remaining length: %zu", p->_packet.fixedHeader.remainingLength.remainingLength);
return ParserResult::awaitData;
}
p->_parse = _fixedHeader;
emc_log_w("Invalid remaining length (fixed): %zu", p->_packet.fixedHeader.remainingLength.remainingLength);
return ParserResult::protocolError;
}
ParserResult Parser::_remainingLengthVariable(Parser* p) {
p->_packet.fixedHeader.remainingLength.remainingLengthRaw[p->_bytePos] = p->_data[p->_bytesRead];
if (p->_packet.fixedHeader.remainingLength.remainingLengthRaw[p->_bytePos] & 0x80) {
p->_bytePos++;
if (p->_bytePos == 4) {
emc_log_w("Invalid remaining length (variable)");
return ParserResult::protocolError;
} else {
return ParserResult::awaitData;
}
}
// no need to check for negative decoded length, check is already done
p->_packet.fixedHeader.remainingLength.remainingLength = decodeRemainingLength(p->_packet.fixedHeader.remainingLength.remainingLengthRaw);
if ((p->_packet.fixedHeader.packetType & 0xF0) == PacketType.PUBLISH) {
p->_parse = _varHeaderTopicLength1;
emc_log_i("Remaining length: %zu", p->_packet.fixedHeader.remainingLength.remainingLength);
return ParserResult::awaitData;
} else {
int32_t payloadSize = p->_packet.fixedHeader.remainingLength.remainingLength - 2; // total - packet ID
if (0 < payloadSize && payloadSize < EMC_PAYLOAD_BUFFER_SIZE) {
p->_bytePos = 0;
p->_packet.payload.data = p->_payloadBuffer;
p->_packet.payload.index = 0;
p->_packet.payload.length = payloadSize;
p->_packet.payload.total = payloadSize;
p->_parse = _varHeaderPacketId1;
emc_log_i("Remaining length: %zu", p->_packet.fixedHeader.remainingLength.remainingLength);
return ParserResult::awaitData;
} else {
emc_log_w("Invalid payload length");
}
}
p->_parse = _fixedHeader;
return ParserResult::protocolError;
}
ParserResult Parser::_remainingLengthNone(Parser* p) {
p->_packet.fixedHeader.remainingLength.remainingLength = p->_data[p->_bytesRead];
p->_parse = _fixedHeader;
if (p->_packet.fixedHeader.remainingLength.remainingLength == 0) {
emc_log_i("Remaining length: %zu", p->_packet.fixedHeader.remainingLength.remainingLength);
return ParserResult::packet;
}
emc_log_w("Invalid remaining length (none)");
return ParserResult::protocolError;
}
ParserResult Parser::_varHeaderConnack1(Parser* p) {
uint8_t data = p->_data[p->_bytesRead];
if (data < 2) { // session present flag: equal to 0 or 1
p->_packet.variableHeader.fixed.connackVarHeader.sessionPresent = data;
p->_parse = _varHeaderConnack2;
return ParserResult::awaitData;
}
p->_parse = _fixedHeader;
emc_log_w("Invalid session flags");
return ParserResult::protocolError;
}
ParserResult Parser::_varHeaderConnack2(Parser* p) {
uint8_t data = p->_data[p->_bytesRead];
p->_parse = _fixedHeader;
if (data <= 5) { // connect return code max is 5
p->_packet.variableHeader.fixed.connackVarHeader.returnCode = data;
emc_log_i("Packet complete");
return ParserResult::packet;
}
emc_log_w("Invalid connack return code");
return ParserResult::protocolError;
}
ParserResult Parser::_varHeaderPacketId1(Parser* p) {
p->_packet.variableHeader.fixed.packetId |= p->_data[p->_bytesRead] << 8;
p->_parse = _varHeaderPacketId2;
return ParserResult::awaitData;
}
ParserResult Parser::_varHeaderPacketId2(Parser* p) {
p->_packet.variableHeader.fixed.packetId |= p->_data[p->_bytesRead];
p->_parse = _fixedHeader;
if (p->_packet.variableHeader.fixed.packetId != 0) {
emc_log_i("Packet variable header complete");
if ((p->_packet.fixedHeader.packetType & 0xF0) == PacketType.SUBACK) {
p->_parse = _payloadSuback;
return ParserResult::awaitData;
} else if ((p->_packet.fixedHeader.packetType & 0xF0) == PacketType.PUBLISH) {
p->_packet.payload.total -= 2; // substract packet id length from payload
if (p->_packet.payload.total == 0) {
p->_parse = _fixedHeader;
return ParserResult::packet;
} else {
p->_parse = _payloadPublish;
}
return ParserResult::awaitData;
} else {
return ParserResult::packet;
}
} else {
emc_log_w("Invalid packet id");
return ParserResult::protocolError;
}
}
ParserResult Parser::_varHeaderTopicLength1(Parser* p) {
p->_packet.variableHeader.topicLength = p->_data[p->_bytesRead] << 8;
p->_parse = _varHeaderTopicLength2;
return ParserResult::awaitData;
}
ParserResult Parser::_varHeaderTopicLength2(Parser* p) {
p->_packet.variableHeader.topicLength |= p->_data[p->_bytesRead];
size_t maxTopicLength =
p->_packet.fixedHeader.remainingLength.remainingLength
- 2 // topic length bytes
- ((p->_packet.fixedHeader.packetType & (HeaderFlag.PUBLISH_QOS1 | HeaderFlag.PUBLISH_QOS2)) ? 2 : 0);
if (p->_packet.variableHeader.topicLength <= maxTopicLength) {
p->_parse = _varHeaderTopic;
p->_bytePos = 0;
p->_packet.payload.total = p->_packet.fixedHeader.remainingLength.remainingLength - 2 - p->_packet.variableHeader.topicLength;
return ParserResult::awaitData;
}
emc_log_w("Invalid topic length: %u > %zu", p->_packet.variableHeader.topicLength, maxTopicLength);
p->_parse = _fixedHeader;
return ParserResult::protocolError;
}
ParserResult Parser::_varHeaderTopic(Parser* p) {
// no checking for character [MQTT-3.3.2-1] [MQTT-3.3.2-2]
p->_packet.variableHeader.topic[p->_bytePos] = static_cast<char>(p->_data[p->_bytesRead]);
p->_bytePos++;
if (p->_bytePos == p->_packet.variableHeader.topicLength || p->_bytePos == EMC_MAX_TOPIC_LENGTH) {
p->_packet.variableHeader.topic[p->_bytePos] = 0x00; // add c-string delimiter
emc_log_i("Packet variable header topic complete");
if (p->_packet.fixedHeader.packetType & (HeaderFlag.PUBLISH_QOS1 | HeaderFlag.PUBLISH_QOS2)) {
p->_parse = _varHeaderPacketId1;
} else if (p->_packet.payload.total == 0) {
p->_parse = _fixedHeader;
return ParserResult::packet;
} else {
p->_parse = _payloadPublish;
}
}
return ParserResult::awaitData;
}
ParserResult Parser::_payloadSuback(Parser* p) {
uint8_t data = p->_data[p->_bytesRead];
if (data < 0x03 || data == 0x80) {
p->_payloadBuffer[p->_bytePos] = data;
p->_bytePos++;
} else {
p->_parse = _fixedHeader;
emc_log_w("Invalid suback return code");
return ParserResult::protocolError;
}
if (p->_bytePos == p->_packet.payload.total) {
p->_parse = _fixedHeader;
emc_log_i("Packet complete");
return ParserResult::packet;
}
return ParserResult::awaitData;
}
ParserResult Parser::_payloadPublish(Parser* p) {
p->_packet.payload.index += p->_packet.payload.length;
p->_packet.payload.data = &p->_data[p->_bytesRead];
emc_log_i("payload: index %zu, total %zu, avail %zu/%zu", p->_packet.payload.index, p->_packet.payload.total, p->_len - p->_bytesRead, p->_len);
p->_packet.payload.length = std::min(p->_len - p->_bytesRead, p->_packet.payload.total - p->_packet.payload.index);
p->_bytesRead += p->_packet.payload.length - 1; // compensate for increment in _parse-loop
if (p->_packet.payload.index + p->_packet.payload.length == p->_packet.payload.total) {
p->_parse = _fixedHeader;
}
return ParserResult::packet;
}
} // end namespace espMqttClientInternals

100
lib/espMqttClient/src/Packets/Parser.h Normal file
View File

@@ -0,0 +1,100 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <algorithm>
#include "../Config.h"
#include "Constants.h"
#include "../Logging.h"
#include "RemainingLength.h"
namespace espMqttClientInternals {
struct IncomingPacket {
struct __attribute__((__packed__)) {
MQTTPacketType packetType;
union {
size_t remainingLength;
uint8_t remainingLengthRaw[4];
} remainingLength;
} fixedHeader;
struct __attribute__((__packed__)) {
uint16_t topicLength;
char topic[EMC_MAX_TOPIC_LENGTH + 1]; // + 1 for c-string delimiter
union {
struct {
uint8_t sessionPresent;
uint8_t returnCode;
} connackVarHeader;
uint16_t packetId;
} fixed;
} variableHeader;
struct {
const uint8_t* data;
size_t length;
size_t index;
size_t total;
} payload;
uint8_t qos() const;
bool retain() const;
bool dup() const;
void reset();
};
enum class ParserResult : uint8_t {
awaitData,
packet,
protocolError
};
class Parser;
typedef ParserResult(*ParserFunc)(Parser*);
class Parser {
public:
Parser();
ParserResult parse(const uint8_t* data, size_t len, size_t* bytesRead);
const IncomingPacket& getPacket() const;
void reset();
private:
// keep data variables in class to avoid copying on every iteration of the parser
const uint8_t* _data;
size_t _len;
size_t _bytesRead;
size_t _bytePos;
ParserFunc _parse;
IncomingPacket _packet;
uint8_t _payloadBuffer[EMC_PAYLOAD_BUFFER_SIZE];
static ParserResult _fixedHeader(Parser* p);
static ParserResult _remainingLengthFixed(Parser* p);
static ParserResult _remainingLengthNone(Parser* p);
static ParserResult _remainingLengthVariable(Parser* p);
static ParserResult _varHeaderConnack1(Parser* p);
static ParserResult _varHeaderConnack2(Parser* p);
static ParserResult _varHeaderPacketId1(Parser* p);
static ParserResult _varHeaderPacketId2(Parser* p);
static ParserResult _varHeaderTopicLength1(Parser* p);
static ParserResult _varHeaderTopicLength2(Parser* p);
static ParserResult _varHeaderTopic(Parser* p);
static ParserResult _payloadSuback(Parser* p);
static ParserResult _payloadPublish(Parser* p);
};
} // end namespace espMqttClientInternals

57
lib/espMqttClient/src/Packets/RemainingLength.cpp Normal file
View File

@@ -0,0 +1,57 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "RemainingLength.h"
namespace espMqttClientInternals {
int32_t decodeRemainingLength(const uint8_t* stream) {
uint32_t multiplier = 1;
int32_t remainingLength = 0;
uint8_t currentByte = 0;
uint8_t encodedByte;
do {
encodedByte = stream[currentByte++];
remainingLength += (encodedByte & 127) * multiplier;
if (multiplier > 128 * 128 * 128) {
emc_log_e("Malformed Remaining Length");
return -1;
}
multiplier *= 128;
} while ((encodedByte & 128) != 0);
return remainingLength;
}
uint8_t remainingLengthLength(uint32_t remainingLength) {
if (remainingLength < 128) return 1;
if (remainingLength < 16384) return 2;
if (remainingLength < 2097152) return 3;
if (remainingLength > 268435455) return 0;
return 4;
}
uint8_t encodeRemainingLength(uint32_t remainingLength, uint8_t* destination) {
uint8_t currentByte = 0;
uint8_t bytesNeeded = 0;
do {
uint8_t encodedByte = remainingLength % 128;
remainingLength /= 128;
if (remainingLength > 0) {
encodedByte = encodedByte | 128;
}
destination[currentByte++] = encodedByte;
bytesNeeded++;
} while (remainingLength > 0);
return bytesNeeded;
}
} // namespace espMqttClientInternals

32
lib/espMqttClient/src/Packets/RemainingLength.h Normal file
View File

@@ -0,0 +1,32 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stdint.h>
#include "../Logging.h"
namespace espMqttClientInternals {
// Calculations are based on non normative comment in section 2.2.3 Remaining Length of the MQTT specification
// returns decoded length based on input stream
// stream is expected to contain full encoded remaining length
// return -1 on error.
int32_t decodeRemainingLength(const uint8_t* stream);
// returns the number of bytes needed to encode the remaining length
uint8_t remainingLengthLength(uint32_t remainingLength);
// encodes the given remaining length to destination and returns number of bytes used
// destination is expected to be large enough to hold the number of bytes needed
uint8_t encodeRemainingLength(uint32_t remainingLength, uint8_t* destination);
} // namespace espMqttClientInternals

26
lib/espMqttClient/src/Packets/String.cpp Normal file
View File

@@ -0,0 +1,26 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "String.h"
namespace espMqttClientInternals {
size_t encodeString(const char* source, uint8_t* dest) {
size_t length = strlen(source);
if (length > 65535) {
emc_log_e("String length error");
return 0;
}
dest[0] = static_cast<uint16_t>(length) >> 8;
dest[1] = static_cast<uint16_t>(length) & 0xFF;
memcpy(&dest[2], source, length);
return 2 + length;
}
} // namespace espMqttClientInternals

22
lib/espMqttClient/src/Packets/String.h Normal file
View File

@@ -0,0 +1,22 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stdint.h>
#include <cstring> // memcpy
#include "../Logging.h"
namespace espMqttClientInternals {
// encodes the given source string into destination and returns number of bytes used
// destination is expected to be large enough to hold the number of bytes needed
size_t encodeString(const char* source, uint8_t* dest);
} // namespace espMqttClientInternals

62
lib/espMqttClient/src/Transport/ClientAsync.cpp Normal file
View File

@@ -0,0 +1,62 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "ClientAsync.h"
namespace espMqttClientInternals {
ClientAsync::ClientAsync()
: client()
, availableData(0)
, bufData(nullptr) {
// empty
}
bool ClientAsync::connect(IPAddress ip, uint16_t port) {
return client.connect(ip, port);
}
bool ClientAsync::connect(const char* host, uint16_t port) {
return client.connect(host, port);
}
size_t ClientAsync::write(const uint8_t* buf, size_t size) {
return client.write(reinterpret_cast<const char*>(buf), size);
}
int ClientAsync::available() {
return static_cast<int>(availableData); // availableData will never be large enough to cause an overflow
}
int ClientAsync::read(uint8_t* buf, size_t size) {
size_t willRead = std::min(size, availableData);
memcpy(buf, bufData, std::min(size, availableData));
if (availableData > size) {
emc_log_w("Buffer is smaller than available data: %zu - %zu", size, availableData);
}
availableData = 0;
return willRead;
}
void ClientAsync::stop() {
client.close(false);
}
bool ClientAsync::connected() {
return client.connected();
}
bool ClientAsync::disconnected() {
return client.disconnected();
}
} // namespace espMqttClientInternals
#endif

45
lib/espMqttClient/src/Transport/ClientAsync.h Normal file
View File

@@ -0,0 +1,45 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#pragma once
#if defined(ARDUINO_ARCH_ESP32)
#include "freertos/FreeRTOS.h"
#include <AsyncTCP.h>
#elif defined(ARDUINO_ARCH_ESP8266)
#include <ESPAsyncTCP.h>
#endif
#include "Transport.h"
#include "../Config.h"
#include "../Logging.h"
namespace espMqttClientInternals {
class ClientAsync : public Transport {
public:
ClientAsync();
bool connect(IPAddress ip, uint16_t port) override;
bool connect(const char* host, uint16_t port) override;
size_t write(const uint8_t* buf, size_t size) override;
int available() override;
int read(uint8_t* buf, size_t size) override;
void stop() override;
bool connected() override;
bool disconnected() override;
AsyncClient client;
size_t availableData;
uint8_t* bufData;
};
} // namespace espMqttClientInternals
#endif

98
lib/espMqttClient/src/Transport/ClientPosix.cpp Normal file
View File

@@ -0,0 +1,98 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "ClientPosix.h"
#if defined(__linux__)
namespace espMqttClientInternals {
ClientPosix::ClientPosix()
: _sockfd(-1)
, _host() {
// empty
}
ClientPosix::~ClientPosix() {
ClientPosix::stop();
}
bool ClientPosix::connect(IPAddress ip, uint16_t port) {
if (connected()) stop();
_sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
if (_sockfd < 0) {
emc_log_e("Error %d opening socket", errno);
}
int flag = 1;
if (setsockopt(_sockfd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int)) < 0) {
emc_log_e("Error %d disabling nagle", errno);
}
memset(&_host, 0, sizeof(_host));
_host.sin_family = AF_INET;
_host.sin_addr.s_addr = htonl(uint32_t(ip));
_host.sin_port = ::htons(port);
int ret = ::connect(_sockfd, (struct sockaddr *)&_host, sizeof(_host));
if (ret < 0) {
emc_log_e("Error connecting: %d - (%d) %s", ret, errno, strerror(errno));
return false;
}
emc_log_i("Connected");
return true;
}
bool ClientPosix::connect(const char* host, uint16_t port) {
// tbi
(void) host;
(void) port;
return false;
}
size_t ClientPosix::write(const uint8_t* buf, size_t size) {
return ::send(_sockfd, buf, size, 0);
}
int ClientPosix::available() {
uint8_t buf[EMC_POSIX_PEEK_SIZE];
int ret = ::recv(_sockfd, &buf, EMC_POSIX_PEEK_SIZE, MSG_DONTWAIT|MSG_PEEK);
return ret;
}
int ClientPosix::read(uint8_t* buf, size_t size) {
int ret = ::recv(_sockfd, buf, size, MSG_DONTWAIT);
/*
if (ret < 0) {
emc_log_e("Error reading: %s", strerror(errno));
}
*/
return ret;
}
void ClientPosix::stop() {
if (_sockfd >= 0) {
::close(_sockfd);
_sockfd = -1;
}
}
bool ClientPosix::connected() {
return _sockfd >= 0;
}
bool ClientPosix::disconnected() {
return _sockfd < 0;
}
} // namespace espMqttClientInternals
#endif

52
lib/espMqttClient/src/Transport/ClientPosix.h Normal file
View File

@@ -0,0 +1,52 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(__linux__)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include "Transport.h" // includes IPAddress
#include "../Logging.h"
#ifndef EMC_POSIX_PEEK_SIZE
#define EMC_POSIX_PEEK_SIZE 1500
#endif
namespace espMqttClientInternals {
class ClientPosix : public Transport {
public:
ClientPosix();
~ClientPosix();
bool connect(IPAddress ip, uint16_t port) override;
bool connect(const char* host, uint16_t port) override;
size_t write(const uint8_t* buf, size_t size) override;
int available() override;
int read(uint8_t* buf, size_t size) override;
void stop() override;
bool connected() override;
bool disconnected() override;
protected:
int _sockfd;
struct sockaddr_in _host;
};
} // namespace espMqttClientInternals
#endif

75
lib/espMqttClient/src/Transport/ClientSecureSync.cpp Normal file
View File

@@ -0,0 +1,75 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "ClientSecureSync.h"
#include <lwip/sockets.h> // socket options
namespace espMqttClientInternals {
ClientSecureSync::ClientSecureSync()
: client() {
// empty
}
bool ClientSecureSync::connect(IPAddress ip, uint16_t port) {
bool ret = client.connect(ip, port); // implicit conversion of return code int --> bool
if (ret) {
#if defined(ARDUINO_ARCH_ESP8266)
client.setNoDelay(true);
#elif defined(ARDUINO_ARCH_ESP32)
// Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure
int val = true;
client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
#endif
}
return ret;
}
bool ClientSecureSync::connect(const char* host, uint16_t port) {
bool ret = client.connect(host, port); // implicit conversion of return code int --> bool
if (ret) {
#if defined(ARDUINO_ARCH_ESP8266)
client.setNoDelay(true);
#elif defined(ARDUINO_ARCH_ESP32)
// Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure
int val = true;
client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
#endif
}
return ret;
}
size_t ClientSecureSync::write(const uint8_t* buf, size_t size) {
return client.write(buf, size);
}
int ClientSecureSync::available() {
return client.available();
}
int ClientSecureSync::read(uint8_t* buf, size_t size) {
return client.read(buf, size);
}
void ClientSecureSync::stop() {
client.stop();
}
bool ClientSecureSync::connected() {
return client.connected();
}
bool ClientSecureSync::disconnected() {
return !client.connected();
}
} // namespace espMqttClientInternals
#endif

35
lib/espMqttClient/src/Transport/ClientSecureSync.h Normal file
View File

@@ -0,0 +1,35 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include <WiFiClientSecure.h> // includes IPAddress
#include "Transport.h"
namespace espMqttClientInternals {
class ClientSecureSync : public Transport {
public:
ClientSecureSync();
bool connect(IPAddress ip, uint16_t port) override;
bool connect(const char* host, uint16_t port) override;
size_t write(const uint8_t* buf, size_t size) override;
int available() override;
int read(uint8_t* buf, size_t size) override;
void stop() override;
bool connected() override;
bool disconnected() override;
WiFiClientSecure client;
};
} // namespace espMqttClientInternals
#endif

75
lib/espMqttClient/src/Transport/ClientSync.cpp Normal file
View File

@@ -0,0 +1,75 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "ClientSync.h"
#include <lwip/sockets.h> // socket options
namespace espMqttClientInternals {
ClientSync::ClientSync(WiFiClient* wiFiClient)
: client(wiFiClient) {
// empty
}
bool ClientSync::connect(IPAddress ip, uint16_t port) {
bool ret = client->connect(ip, port); // implicit conversion of return code int --> bool
if (ret) {
#if defined(ARDUINO_ARCH_ESP8266)
client->setNoDelay(true);
#elif defined(ARDUINO_ARCH_ESP32)
// Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
int val = true;
client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
#endif
}
return ret;
}
bool ClientSync::connect(const char* host, uint16_t port) {
bool ret = client->connect(host, port); // implicit conversion of return code int --> bool
if (ret) {
#if defined(ARDUINO_ARCH_ESP8266)
client->setNoDelay(true);
#elif defined(ARDUINO_ARCH_ESP32)
// Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
int val = true;
client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
#endif
}
return ret;
}
size_t ClientSync::write(const uint8_t* buf, size_t size) {
return client->write(buf, size);
}
int ClientSync::available() {
return client->available();
}
int ClientSync::read(uint8_t* buf, size_t size) {
return client->read(buf, size);
}
void ClientSync::stop() {
client->stop();
}
bool ClientSync::connected() {
return client->connected();
}
bool ClientSync::disconnected() {
return !client->connected();
}
} // namespace espMqttClientInternals
#endif

35
lib/espMqttClient/src/Transport/ClientSync.h Normal file
View File

@@ -0,0 +1,35 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include <WiFiClient.h> // includes IPAddress
#include "Transport.h"
namespace espMqttClientInternals {
class ClientSync : public Transport {
public:
ClientSync(WiFiClient* wiFiClient);
bool connect(IPAddress ip, uint16_t port) override;
bool connect(const char* host, uint16_t port) override;
size_t write(const uint8_t* buf, size_t size) override;
int available() override;
int read(uint8_t* buf, size_t size) override;
void stop() override;
bool connected() override;
bool disconnected() override;
WiFiClient* client;
};
} // namespace espMqttClientInternals
#endif

79
lib/espMqttClient/src/Transport/ClientSyncEthernet.cpp Normal file
View File

@@ -0,0 +1,79 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "ClientSyncEthernet.h"
#include <lwip/sockets.h> // socket options
namespace espMqttClientInternals {
ClientSyncEthernet::ClientSyncEthernet(EthernetClient* ethernetClient)
: client(ethernetClient) {
// empty
}
bool ClientSyncEthernet::connect(IPAddress ip, uint16_t port) {
bool ret = client->connect(ip, port); // implicit conversion of return code int --> bool
if (ret) {
#if defined(ARDUINO_ARCH_ESP8266)
client->setNoDelay(true);
#elif defined(ARDUINO_ARCH_ESP32)
// Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
int val = true;
// TODO
// client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
#endif
}
return ret;
}
bool ClientSyncEthernet::connect(const char* host, uint16_t port) {
bool ret = client->connect(host, port); // implicit conversion of return code int --> bool
if (ret) {
#if defined(ARDUINO_ARCH_ESP8266)
client->setNoDelay(true);
#elif defined(ARDUINO_ARCH_ESP32)
// Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
int val = true;
// TODO
// client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
#endif
}
return ret;
}
size_t ClientSyncEthernet::write(const uint8_t* buf, size_t size) {
return client->write(buf, size);
}
int ClientSyncEthernet::available() {
return client->available();
}
int ClientSyncEthernet::read(uint8_t* buf, size_t size) {
return client->read(buf, size);
}
void ClientSyncEthernet::stop() {
client->stop();
}
bool ClientSyncEthernet::connected() {
return client->connected();
}
bool ClientSyncEthernet::disconnected() {
return !client->connected();
}
} // namespace espMqttClientInternals
#endif

26
lib/espMqttClient/src/Transport/ClientSyncEthernet.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "Transport.h"
#include "EthernetClient.h"
namespace espMqttClientInternals {
class ClientSyncEthernet : public Transport {
public:
ClientSyncEthernet(EthernetClient* ethernetClient);
bool connect(IPAddress ip, uint16_t port) override;
bool connect(const char* host, uint16_t port) override;
size_t write(const uint8_t* buf, size_t size) override;
int available() override;
int read(uint8_t* buf, size_t size) override;
void stop() override;
bool connected() override;
bool disconnected() override;
EthernetClient* client;
};
} // namespace espMqttClientInternals
#endif

32
lib/espMqttClient/src/Transport/IPAddress.cpp Normal file
View File

@@ -0,0 +1,32 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(__linux__)
#include "IPAddress.h"
IPAddress::IPAddress()
: _address(0) {
// empty
}
IPAddress::IPAddress(uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3)
: _address(0) {
_address = (uint32_t)p0 << 24 | (uint32_t)p1 << 16 | (uint32_t)p2 << 8 | p3;
}
IPAddress::IPAddress(uint32_t address)
: _address(address) {
// empty
}
IPAddress::operator uint32_t() {
return _address;
}
#endif

28
lib/espMqttClient/src/Transport/IPAddress.h Normal file
View File

@@ -0,0 +1,28 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO)
#include <IPAddress.h>
#else
#include <stdint.h>
class IPAddress {
public:
IPAddress();
IPAddress(uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3);
explicit IPAddress(uint32_t address);
operator uint32_t();
protected:
uint32_t _address;
};
#endif

29
lib/espMqttClient/src/Transport/Transport.h Normal file
View File

@@ -0,0 +1,29 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stddef.h> // size_t
#include "IPAddress.h"
namespace espMqttClientInternals {
class Transport {
public:
virtual bool connect(IPAddress ip, uint16_t port) = 0;
virtual bool connect(const char* host, uint16_t port) = 0;
virtual size_t write(const uint8_t* buf, size_t size) = 0;
virtual int available() = 0;
virtual int read(uint8_t* buf, size_t size) = 0;
virtual void stop() = 0;
virtual bool connected() = 0;
virtual bool disconnected() = 0;
};
} // namespace espMqttClientInternals

51
lib/espMqttClient/src/TypeDefs.cpp Normal file
View File

@@ -0,0 +1,51 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
Parts are based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "TypeDefs.h"
namespace espMqttClientTypes {
const char* disconnectReasonToString(DisconnectReason reason) {
switch (reason) {
case DisconnectReason::USER_OK: return "No error";
case DisconnectReason::MQTT_UNACCEPTABLE_PROTOCOL_VERSION: return "Unacceptable protocol version";
case DisconnectReason::MQTT_IDENTIFIER_REJECTED: return "Identified rejected";
case DisconnectReason::MQTT_SERVER_UNAVAILABLE: return "Server unavailable";
case DisconnectReason::MQTT_MALFORMED_CREDENTIALS: return "Malformed credentials";
case DisconnectReason::MQTT_NOT_AUTHORIZED: return "Not authorized";
case DisconnectReason::TLS_BAD_FINGERPRINT: return "Bad fingerprint";
case DisconnectReason::TCP_DISCONNECTED: return "TCP disconnected";
default: return "";
}
}
const char* subscribeReturncodeToString(SubscribeReturncode returnCode) {
switch (returnCode) {
case SubscribeReturncode::QOS0: return "QoS 0";
case SubscribeReturncode::QOS1: return "QoS 1";
case SubscribeReturncode::QOS2: return "QoS 2";
case SubscribeReturncode::FAIL: return "Failed";
default: return "";
}
}
const char* errorToString(Error error) {
switch (error) {
case Error::SUCCESS: return "Success";
case Error::OUT_OF_MEMORY: return "Out of memory";
case Error::MAX_RETRIES: return "Maximum retries exceeded";
case Error::MALFORMED_PARAMETER: return "Malformed parameters";
case Error::MISC_ERROR: return "Misc error";
default: return "";
}
}
} // end namespace espMqttClientTypes

68
lib/espMqttClient/src/TypeDefs.h Normal file
View File

@@ -0,0 +1,68 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
Parts are based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <functional>
namespace espMqttClientTypes {
enum class DisconnectReason : uint8_t {
USER_OK = 0,
MQTT_UNACCEPTABLE_PROTOCOL_VERSION = 1,
MQTT_IDENTIFIER_REJECTED = 2,
MQTT_SERVER_UNAVAILABLE = 3,
MQTT_MALFORMED_CREDENTIALS = 4,
MQTT_NOT_AUTHORIZED = 5,
TLS_BAD_FINGERPRINT = 6,
TCP_DISCONNECTED = 7
};
const char* disconnectReasonToString(DisconnectReason reason);
enum class SubscribeReturncode : uint8_t {
QOS0 = 0x00,
QOS1 = 0x01,
QOS2 = 0x02,
FAIL = 0X80
};
const char* subscribeReturncodeToString(SubscribeReturncode returnCode);
enum class Error : uint8_t {
SUCCESS = 0,
OUT_OF_MEMORY = 1,
MAX_RETRIES = 2,
MALFORMED_PARAMETER = 3,
MISC_ERROR = 4
};
const char* errorToString(Error error);
struct MessageProperties {
uint8_t qos;
bool dup;
bool retain;
uint16_t packetId;
};
typedef std::function<void(bool sessionPresent)> OnConnectCallback;
typedef std::function<void(DisconnectReason reason)> OnDisconnectCallback;
typedef std::function<void(uint16_t packetId, const SubscribeReturncode* returncodes, size_t len)> OnSubscribeCallback;
typedef std::function<void(uint16_t packetId)> OnUnsubscribeCallback;
typedef std::function<void(const MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total)> OnMessageCallback;
typedef std::function<void(uint16_t packetId)> OnPublishCallback;
typedef std::function<size_t(uint8_t* data, size_t maxSize, size_t index)> PayloadCallback;
typedef std::function<void(uint16_t packetId, Error error)> OnErrorCallback;
} // end namespace espMqttClientTypes

97
lib/espMqttClient/src/espMqttClient.cpp Normal file
View File

@@ -0,0 +1,97 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#include "espMqttClient.h"
#if defined(ARDUINO_ARCH_ESP32)
espMqttClient::espMqttClient(WiFiClient* wiFiClient, uint8_t priority, uint8_t core)
: MqttClientSetup(true, priority, core)
, _client(wiFiClient) {
#else
espMqttClient::espMqttClient()
: _client() {
#endif
_transport = &_client;
}
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#if defined(ARDUINO_ARCH_ESP32)
espMqttClientSecure::espMqttClientSecure(uint8_t priority, uint8_t core)
: MqttClientSetup(priority, core)
, _client() {
#else
espMqttClientSecure::espMqttClientSecure()
: _client() {
#endif
_transport = &_client;
}
espMqttClientSecure& espMqttClientSecure::setInsecure() {
_client.client.setInsecure();
return *this;
}
#if defined(ARDUINO_ARCH_ESP32)
espMqttClientSecure& espMqttClientSecure::setCACert(const char* rootCA) {
_client.client.setCACert(rootCA);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setCertificate(const char* clientCa) {
_client.client.setCertificate(clientCa);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setPrivateKey(const char* privateKey) {
_client.client.setPrivateKey(privateKey);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setPreSharedKey(const char* pskIdent, const char* psKey) {
_client.client.setPreSharedKey(pskIdent, psKey);
return *this;
}
#elif defined(ARDUINO_ARCH_ESP8266)
espMqttClientSecure& espMqttClientSecure::setFingerprint(const uint8_t fingerprint[20]) {
_client.client.setFingerprint(fingerprint);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setTrustAnchors(const X509List *ta) {
_client.client.setTrustAnchors(ta);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setClientRSACert(const X509List *cert, const PrivateKey *sk) {
_client.client.setClientRSACert(cert, sk);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type) {
_client.client.setClientECCert(cert, sk, allowed_usages, cert_issuer_key_type);
return *this;
}
espMqttClientSecure& espMqttClientSecure::setCertStore(CertStoreBase *certStore) {
_client.client.setCertStore(certStore);
return *this;
}
#endif
#endif
#if defined(ARDUINO_ARCH_ESP32)
espMqttClientEthernet::espMqttClientEthernet(EthernetClient* ethernetClient, uint8_t priority, uint8_t core)
: MqttClientSetup(true, priority, core)
, _client(ethernetClient) {
#else
espMqttClientEthernet::espMqttClientEthernet()
: _client() {
#endif
_transport = &_client;
}

82
lib/espMqttClient/src/espMqttClient.h Normal file
View File

@@ -0,0 +1,82 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
API is based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "Transport/ClientSync.h"
#include "Transport/ClientSecureSync.h"
#elif defined(__linux__)
#include "Transport/ClientPosix.h"
#endif
#include "MqttClientSetup.h"
#include "Transport/ClientSyncEthernet.h"
class espMqttClient : public MqttClientSetup {
public:
#if defined(ARDUINO_ARCH_ESP32)
explicit espMqttClient(WiFiClient* wiFiClient, uint8_t priority = 1, uint8_t core = 1);
#else
espMqttClient();
#endif
protected:
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
espMqttClientInternals::ClientSync _client;
#elif defined(__linux__)
espMqttClientInternals::ClientPosix _client;
#endif
};
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
class espMqttClientSecure : public MqttClientSetup {
public:
#if defined(ARDUINO_ARCH_ESP32)
explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1);
#else
espMqttClientSecure();
#endif
espMqttClientSecure& setInsecure();
#if defined(ARDUINO_ARCH_ESP32)
espMqttClientSecure& setCACert(const char* rootCA);
espMqttClientSecure& setCertificate(const char* clientCa);
espMqttClientSecure& setPrivateKey(const char* privateKey);
espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey);
#else
espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20]);
espMqttClientSecure& setTrustAnchors(const X509List *ta);
espMqttClientSecure& setClientRSACert(const X509List *cert, const PrivateKey *sk);
espMqttClientSecure& setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type);
espMqttClientSecure& setCertStore(CertStoreBase *certStore);
#endif
protected:
espMqttClientInternals::ClientSecureSync _client;
};
class espMqttClientEthernet : public MqttClientSetup {
public:
#if defined(ARDUINO_ARCH_ESP32)
explicit espMqttClientEthernet(EthernetClient* ethernetClient, uint8_t priority = 1, uint8_t core = 1);
#else
espMqttClient();
#endif
protected:
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
espMqttClientInternals::ClientSyncEthernet _client;
#elif defined(__linux__)
espMqttClientInternals::ClientPosix _client;
#endif
};
#endif

68
lib/espMqttClient/src/espMqttClientAsync.cpp Normal file
View File

@@ -0,0 +1,68 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "espMqttClientAsync.h"
#if defined(ARDUINO_ARCH_ESP32)
espMqttClientAsync::espMqttClientAsync(uint8_t priority, uint8_t core)
: MqttClientSetup(false, priority, core)
, _clientAsync() {
#else
espMqttClientAsync::espMqttClientAsync()
: _clientAsync() {
#endif
_transport = &_clientAsync;
// _onConnectHook = reinterpret_cast<MqttClient::OnConnectHook>(_setupClient);
// _onConnectHookArg = this;
_clientAsync.client.onConnect(onConnectCb, this);
_clientAsync.client.onDisconnect(onDisconnectCb, this);
_clientAsync.client.onData(onDataCb, this);
_clientAsync.client.onPoll(onPollCb, this);
}
bool espMqttClientAsync::connect() {
bool ret = MqttClient::connect();
loop();
return ret;
}
void espMqttClientAsync::_setupClient(espMqttClientAsync* c) {
(void)c;
}
void espMqttClientAsync::onConnectCb(void* a, AsyncClient* c) {
c->setNoDelay(true);
espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
client->_state = MqttClient::State::connectingTcp2;
client->loop();
}
void espMqttClientAsync::onDataCb(void* a, AsyncClient* c, void* data, size_t len) {
(void)c;
espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
client->_clientAsync.bufData = reinterpret_cast<uint8_t*>(data);
client->_clientAsync.availableData = len;
client->loop();
}
void espMqttClientAsync::onDisconnectCb(void* a, AsyncClient* c) {
(void)c;
espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
client->_state = MqttClient::State::disconnectingTcp2;
client->loop();
}
void espMqttClientAsync::onPollCb(void* a, AsyncClient* c) {
(void)c;
espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
client->loop();
}
#endif

40
lib/espMqttClient/src/espMqttClientAsync.h Normal file
View File

@@ -0,0 +1,40 @@
/*
Copyright (c) 2022 Bert Melis. All rights reserved.
API is based on the original work of Marvin Roger:
https://github.com/marvinroger/async-mqtt-client
This work is licensed under the terms of the MIT license.
For a copy, see <https://opensource.org/licenses/MIT> or
the LICENSE file.
*/
#pragma once
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
#include "Transport/ClientAsync.h"
#include "MqttClientSetup.h"
class espMqttClientAsync : public MqttClientSetup {
public:
#if defined(ARDUINO_ARCH_ESP32)
explicit espMqttClientAsync(uint8_t priority = 1, uint8_t core = 1);
#else
espMqttClientAsync();
#endif
bool connect();
protected:
espMqttClientInternals::ClientAsync _clientAsync;
static void _setupClient(espMqttClientAsync* c);
static void _disconnectClient(espMqttClientAsync* c);
static void onConnectCb(void* a, AsyncClient* c);
static void onDataCb(void* a, AsyncClient* c, void* data, size_t len);
static void onDisconnectCb(void* a, AsyncClient* c);
static void onPollCb(void* a, AsyncClient* c);
};
#endif

22
lib/espMqttClient/test-coverage.py Normal file
View File

@@ -0,0 +1,22 @@
import os
Import("env", "projenv")
# Dump build environment (for debug purpose)
print(env.Dump())
# access to global build environment
print(env)
# access to the project build environment
# (used for source files located in the "src" folder)
print(projenv)
def generateCoverageInfo(source, target, env):
for file in os.listdir("test"):
os.system(".pio/build/native/program test/"+file)
os.system("lcov -d .pio/build/native/ -c -o lcov.info")
os.system("lcov --remove lcov.info '*Unity*' '*unity*' '/usr/include/*' '*/test/*' -o filtered_lcov.info")
os.system("genhtml -o cov/ --demangle-cpp filtered_lcov.info")
env.AddPostAction(".pio/build/native/program", generateCoverageInfo)

313
lib/espMqttClient/test/test_client_native/test_client_native.cpp Normal file
View File

@@ -0,0 +1,313 @@
#include <unity.h>
#include <thread>
#include <iostream>
#include <espMqttClient.h> // espMqttClient for Linux also defines millis()
void setUp() {}
void tearDown() {}
espMqttClient mqttClient;
std::atomic_bool exitProgram(false);
std::thread t;
const IPAddress broker(127,0,0,1);
//const char* broker = "localhost";
const uint16_t broker_port = 1883;
/*
- setup the client with basic settings
- connect to the broker
- successfully connect
*/
void test_connect() {
std::atomic<bool> onConnectCalledTest(false);
bool sessionPresentTest = true;
mqttClient.setServer(broker, broker_port)
.setCleanSession(true)
.setKeepAlive(5)
.onConnect([&](bool sessionPresent) mutable {
sessionPresentTest = sessionPresent;
onConnectCalledTest = true;
});
mqttClient.connect();
uint32_t start = millis();
while (millis() - start < 2000) {
if (onConnectCalledTest) {
break;
}
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_TRUE(onConnectCalledTest);
TEST_ASSERT_FALSE(sessionPresentTest);
}
/*
- keepalive is set at 5 seconds in previous test
- client should stay connected during 2x keepalive period
*/
void test_ping() {
bool pingTest = true;
uint32_t start = millis();
while (millis() - start < 11000) {
if (mqttClient.disconnected()) {
pingTest = false;
break;
}
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_TRUE(pingTest);
}
/*
- client subscribes to topic
- ack is received from broker
*/
void test_subscribe() {
std::atomic<bool> subscribeTest(false);
mqttClient.onSubscribe([&](uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* returncodes, size_t len) mutable {
(void) packetId;
if (len == 1 && returncodes[0] == espMqttClientTypes::SubscribeReturncode::QOS0) {
subscribeTest = true;
}
});
mqttClient.subscribe("test/test", 0);
uint32_t start = millis();
while (millis() - start < 2000) {
if (subscribeTest) {
break;
}
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_TRUE(subscribeTest);
}
/*
- client publishes using all three qos levels
- all publish get packetID returned > 0 (equal to 1 for qos 0)
- 2 pubacks are received
*/
void test_publish() {
std::atomic<int> publishSendTest(0);
mqttClient.onPublish([&](uint16_t packetId) mutable {
(void) packetId;
publishSendTest++;
});
std::atomic<int> publishReceiveTest(0);
mqttClient.onMessage([&](const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) mutable {
(void) properties;
(void) topic;
(void) payload;
(void) len;
(void) index;
(void) total;
publishReceiveTest++;
});
uint16_t sendQos0Test = mqttClient.publish("test/test", 0, false, "test0");
uint16_t sendQos1Test = mqttClient.publish("test/test", 1, false, "test1");
uint16_t sendQos2Test = mqttClient.publish("test/test", 2, false, "test2");
uint32_t start = millis();
while (millis() - start < 6000) {
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_EQUAL_UINT16(1, sendQos0Test);
TEST_ASSERT_GREATER_THAN_UINT16(0, sendQos1Test);
TEST_ASSERT_GREATER_THAN_UINT16(0, sendQos2Test);
TEST_ASSERT_EQUAL_INT(2, publishSendTest);
TEST_ASSERT_EQUAL_INT(3, publishReceiveTest);
}
void test_publish_empty() {
std::atomic<int> publishSendEmptyTest(0);
mqttClient.onPublish([&](uint16_t packetId) mutable {
(void) packetId;
publishSendEmptyTest++;
});
std::atomic<int> publishReceiveEmptyTest(0);
mqttClient.onMessage([&](const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) mutable {
(void) properties;
(void) topic;
(void) payload;
(void) len;
(void) index;
(void) total;
publishReceiveEmptyTest++;
});
uint16_t sendQos0Test = mqttClient.publish("test/test", 0, false, nullptr, 0);
uint16_t sendQos1Test = mqttClient.publish("test/test", 1, false, nullptr, 0);
uint16_t sendQos2Test = mqttClient.publish("test/test", 2, false, nullptr, 0);
uint32_t start = millis();
while (millis() - start < 6000) {
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_EQUAL_UINT16(1, sendQos0Test);
TEST_ASSERT_GREATER_THAN_UINT16(0, sendQos1Test);
TEST_ASSERT_GREATER_THAN_UINT16(0, sendQos2Test);
TEST_ASSERT_EQUAL_INT(2, publishSendEmptyTest);
TEST_ASSERT_EQUAL_INT(3, publishReceiveEmptyTest);
}
/*
- subscribe to test/test, qos 1
- send to test/test, qos 1
- check if message is received at least once.
*/
void test_receive1() {
std::atomic<int> publishReceive1Test(0);
mqttClient.onMessage([&](const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) mutable {
(void) properties;
(void) topic;
(void) payload;
(void) len;
(void) index;
(void) total;
publishReceive1Test++;
});
mqttClient.onSubscribe([&](uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* returncodes, size_t len) mutable {
(void) packetId;
if (len == 1 && returncodes[0] == espMqttClientTypes::SubscribeReturncode::QOS1) {
mqttClient.publish("test/test", 1, false, "");
}
});
mqttClient.subscribe("test/test", 1);
uint32_t start = millis();
while (millis() - start < 6000) {
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_GREATER_THAN_INT(0, publishReceive1Test);
}
/*
- subscribe to test/test, qos 2
- send to test/test, qos 2
- check if message is received exactly once.
*/
void test_receive2() {
std::atomic<int> publishReceive2Test(0);
mqttClient.onMessage([&](const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) mutable {
(void) properties;
(void) topic;
(void) payload;
(void) len;
(void) index;
(void) total;
publishReceive2Test++;
});
mqttClient.onSubscribe([&](uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* returncodes, size_t len) mutable {
(void) packetId;
if (len == 1 && returncodes[0] == espMqttClientTypes::SubscribeReturncode::QOS2) {
mqttClient.publish("test/test", 2, false, "");
}
});
mqttClient.subscribe("test/test", 2);
uint32_t start = millis();
while (millis() - start < 6000) {
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_EQUAL_INT(1, publishReceive2Test);
}
/*
- client unsibscribes from topic
*/
void test_unsubscribe() {
std::atomic<bool> unsubscribeTest(false);
mqttClient.onUnsubscribe([&](uint16_t packetId) mutable {
(void) packetId;
unsubscribeTest = true;
});
mqttClient.unsubscribe("test/test");
uint32_t start = millis();
while (millis() - start < 2000) {
if (unsubscribeTest) {
break;
}
std::this_thread::yield();
}
TEST_ASSERT_TRUE(mqttClient.connected());
TEST_ASSERT_TRUE(unsubscribeTest);
}
/*
- client disconnects cleanly
*/
void test_disconnect() {
std::atomic<bool> onDisconnectCalled(false);
espMqttClientTypes::DisconnectReason reasonTest = espMqttClientTypes::DisconnectReason::TCP_DISCONNECTED;
mqttClient.onDisconnect([&](espMqttClientTypes::DisconnectReason reason) mutable {
reasonTest = reason;
onDisconnectCalled = true;
});
mqttClient.disconnect();
uint32_t start = millis();
while (millis() - start < 2000) {
if (onDisconnectCalled) {
break;
}
std::this_thread::yield();
}
TEST_ASSERT_TRUE(onDisconnectCalled);
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::DisconnectReason::USER_OK, reasonTest);
TEST_ASSERT_TRUE(mqttClient.disconnected());
}
int main() {
UNITY_BEGIN();
t = std::thread([] {
while (1) {
mqttClient.loop();
if (exitProgram) break;
}
});
RUN_TEST(test_connect);
RUN_TEST(test_ping);
RUN_TEST(test_subscribe);
RUN_TEST(test_publish);
RUN_TEST(test_publish_empty);
RUN_TEST(test_receive1);
RUN_TEST(test_receive2);
RUN_TEST(test_unsubscribe);
RUN_TEST(test_disconnect);
exitProgram = true;
t.join();
return UNITY_END();
}

171
lib/espMqttClient/test/test_outbox/test_outbox.cpp Normal file
View File

@@ -0,0 +1,171 @@
#include <unity.h>
#include <Outbox.h>
using espMqttClientInternals::Outbox;
void setUp() {}
void tearDown() {}
void test_outbox_create() {
Outbox<uint32_t> outbox;
Outbox<uint32_t>::Iterator it = outbox.front();
TEST_ASSERT_NULL(outbox.getCurrent());
TEST_ASSERT_NULL(it.get());
TEST_ASSERT_TRUE(outbox.empty());
}
void test_outbox_emplace() {
Outbox<uint32_t> outbox;
outbox.emplace(1);
// 1, current points to 1
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(1, *(outbox.getCurrent()));
TEST_ASSERT_FALSE(outbox.empty());
outbox.next();
// 1, current points to nullptr
TEST_ASSERT_NULL(outbox.getCurrent());
outbox.emplace(2);
// 1 2, current points to 2
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(2, *(outbox.getCurrent()));
outbox.emplace(3);
// 1 2 3, current points to 2
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(2, *(outbox.getCurrent()));
}
void test_outbox_emplaceFront() {
Outbox<uint32_t> outbox;
outbox.emplaceFront(1);
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(1, *(outbox.getCurrent()));
outbox.emplaceFront(2);
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(2, *(outbox.getCurrent()));
}
void test_outbox_remove1() {
Outbox<uint32_t> outbox;
Outbox<uint32_t>::Iterator it;
outbox.emplace(1);
outbox.emplace(2);
outbox.emplace(3);
outbox.emplace(4);
outbox.next();
outbox.next();
it = outbox.front();
++it;
++it;
++it;
++it;
outbox.remove(it);
// 1 2 3 4, it points to nullptr, current points to 3
TEST_ASSERT_NULL(it.get());
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(3, *(outbox.getCurrent()));
it = outbox.front();
++it;
++it;
++it;
outbox.remove(it);
// 1 2 3, it points to nullptr, current points to 3
TEST_ASSERT_NULL(it.get());
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(3, *(outbox.getCurrent()));
it = outbox.front();
outbox.remove(it);
// 2 3, it points to 2, current points to 3
TEST_ASSERT_NOT_NULL(it.get());
TEST_ASSERT_EQUAL_UINT32(2, *(it.get()));
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(3, *(outbox.getCurrent()));
it = outbox.front();
outbox.remove(it);
// 3, it points to 3, current points to 3
TEST_ASSERT_NOT_NULL(it.get());
TEST_ASSERT_EQUAL_UINT32(3, *(it.get()));
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(3, *(outbox.getCurrent()));
it = outbox.front();
outbox.remove(it);
TEST_ASSERT_NULL(it.get());
TEST_ASSERT_NULL(outbox.getCurrent());
}
void test_outbox_remove2() {
Outbox<uint32_t> outbox;
Outbox<uint32_t>::Iterator it;
outbox.emplace(1);
outbox.emplace(2);
outbox.next();
outbox.next();
it = outbox.front();
// 1 2, current points to nullptr
TEST_ASSERT_NULL(outbox.getCurrent());
TEST_ASSERT_NOT_NULL(it.get());
TEST_ASSERT_EQUAL_UINT32(1, *(it.get()));
++it;
// 1 2, current points to nullptr
TEST_ASSERT_NOT_NULL(it.get());
TEST_ASSERT_EQUAL_UINT32(2, *(it.get()));
outbox.remove(it);
// 1, current points to nullptr
TEST_ASSERT_NULL(outbox.getCurrent());
TEST_ASSERT_NULL(it.get());
it = outbox.front();
TEST_ASSERT_NOT_NULL(it.get());
TEST_ASSERT_EQUAL_UINT32(1, *(it.get()));
outbox.remove(it);
TEST_ASSERT_NULL(it.get());
TEST_ASSERT_TRUE(outbox.empty());
}
void test_outbox_removeCurrent() {
Outbox<uint32_t> outbox;
outbox.emplace(1);
outbox.emplace(2);
outbox.emplace(3);
outbox.emplace(4);
outbox.removeCurrent();
// 2 3 4, current points to 2
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(2, *(outbox.getCurrent()));
outbox.next();
outbox.removeCurrent();
// 2 4, current points to 4
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
TEST_ASSERT_EQUAL_UINT32(4, *(outbox.getCurrent()));
outbox.removeCurrent();
// 4, current points to nullptr
TEST_ASSERT_NULL(outbox.getCurrent());
// outbox will go out of scope and destructor will be called
// Valgrind should not detect a leak here
}
int main() {
UNITY_BEGIN();
RUN_TEST(test_outbox_create);
RUN_TEST(test_outbox_emplace);
RUN_TEST(test_outbox_emplaceFront);
RUN_TEST(test_outbox_remove1);
RUN_TEST(test_outbox_remove2);
RUN_TEST(test_outbox_removeCurrent);
return UNITY_END();
}

714
lib/espMqttClient/test/test_packets/test_packets.cpp Normal file
View File

@@ -0,0 +1,714 @@
#include <unity.h>
#include <Packets/Packet.h>
using espMqttClientInternals::Packet;
using espMqttClientInternals::PacketType;
void setUp() {}
void tearDown() {}
void test_encodeConnect0() {
const uint8_t check[] = {
0b00010000, // header
0x0F, // remaining length
0x00,0x04,'M','Q','T','T', // protocol
0b00000100, // protocol level
0b00000010, // connect flags
0x00,0x10, // keepalive (16)
0x00,0x03,'c','l','i' // client id
};
const uint32_t length = 17;
bool cleanSession = true;
const char* username = nullptr;
const char* password = nullptr;
const char* willTopic = nullptr;
bool willRemain = false;
uint8_t willQoS = 0;
const uint8_t* willPayload = nullptr;
uint16_t willPayloadLength = 0;
uint16_t keepalive = 16;
const char* clientId = "cli";
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
cleanSession,
username,
password,
willTopic,
willRemain,
willQoS,
willPayload,
willPayloadLength,
keepalive,
clientId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.CONNECT, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(0, packet.packetId());
}
void test_encodeConnect1() {
const uint8_t check[] = {
0b00010000, // header
0x20, // remaining length
0x00,0x04,'M','Q','T','T', // protocol
0b00000100, // protocol level
0b11101110, // connect flags
0x00,0x10, // keepalive (16)
0x00,0x03,'c','l','i', // client id
0x00,0x03,'t','o','p', // will topic
0x00,0x02,'p','l', // will payload
0x00,0x02,'u','n', // username
0x00,0x02,'p','a' // password
};
const uint32_t length = 34;
bool cleanSession = true;
const char* username = "un";
const char* password = "pa";
const char* willTopic = "top";
bool willRemain = true;
uint8_t willQoS = 1;
const uint8_t willPayload[] = {'p', 'l'};
uint16_t willPayloadLength = 2;
uint16_t keepalive = 16;
const char* clientId = "cli";
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
cleanSession,
username,
password,
willTopic,
willRemain,
willQoS,
willPayload,
willPayloadLength,
keepalive,
clientId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.CONNECT, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(0, packet.packetId());
}
void test_encodeConnect2() {
const uint8_t check[] = {
0b00010000, // header
0x20, // remaining length
0x00,0x04,'M','Q','T','T', // protocol
0b00000100, // protocol level
0b11110110, // connect flags
0x00,0x10, // keepalive (16)
0x00,0x03,'c','l','i', // client id
0x00,0x03,'t','o','p', // will topic
0x00,0x02,'p','l', // will payload
0x00,0x02,'u','n', // username
0x00,0x02,'p','a' // password
};
const uint32_t length = 34;
bool cleanSession = true;
const char* username = "un";
const char* password = "pa";
const char* willTopic = "top";
bool willRemain = true;
uint8_t willQoS = 2;
const uint8_t willPayload[] = {'p', 'l', '\0'};
uint16_t willPayloadLength = 0;
uint16_t keepalive = 16;
const char* clientId = "cli";
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
cleanSession,
username,
password,
willTopic,
willRemain,
willQoS,
willPayload,
willPayloadLength,
keepalive,
clientId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.CONNECT, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(0, packet.packetId());
}
void test_encodeConnectFail0() {
bool cleanSession = true;
const char* username = nullptr;
const char* password = nullptr;
const char* willTopic = nullptr;
bool willRemain = false;
uint8_t willQoS = 0;
const uint8_t* willPayload = nullptr;
uint16_t willPayloadLength = 0;
uint16_t keepalive = 16;
const char* clientId = "";
espMqttClientTypes::Error error = espMqttClientTypes::Error::SUCCESS;
Packet packet(error,
cleanSession,
username,
password,
willTopic,
willRemain,
willQoS,
willPayload,
willPayloadLength,
keepalive,
clientId);
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::MALFORMED_PARAMETER, error);
}
void test_encodePublish0() {
const uint8_t check[] = {
0b00110000, // header, dup, qos, retain
0x09,
0x00,0x03,'t','o','p', // topic
0x01,0x02,0x03,0x04 // payload
};
const uint32_t length = 11;
const char* topic = "top";
uint8_t qos = 0;
bool retain = false;
const uint8_t payload[] = {0x01, 0x02, 0x03, 0x04};
uint16_t payloadLength = 4;
uint16_t packetId = 22; // any value except 0 for testing
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
packetId,
topic,
payload,
payloadLength,
qos,
retain);
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBLISH, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(0, packet.packetId());
packet.setDup();
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
}
void test_encodePublish1() {
const uint8_t check[] = {
0b00110011, // header, dup, qos, retain
0x0B,
0x00,0x03,'t','o','p', // topic
0x00,0x16, // packet Id
0x01,0x02,0x03,0x04 // payload
};
const uint32_t length = 13;
const char* topic = "top";
uint8_t qos = 1;
bool retain = true;
const uint8_t payload[] = {0x01, 0x02, 0x03, 0x04};
uint16_t payloadLength = 4;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
packetId,
topic,
payload,
payloadLength,
qos,
retain);
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBLISH, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
const uint8_t checkDup[] = {
0b00111011, // header, dup, qos, retain
0x0B,
0x00,0x03,'t','o','p', // topic
0x00,0x16, // packet Id
0x01,0x02,0x03,0x04 // payload
};
packet.setDup();
TEST_ASSERT_EQUAL_UINT8_ARRAY(checkDup, packet.data(0), length);
}
void test_encodePublish2() {
const uint8_t check[] = {
0b00110101, // header, dup, qos, retain
0x0B,
0x00,0x03,'t','o','p', // topic
0x00,0x16, // packet Id
0x01,0x02,0x03,0x04 // payload
};
const uint32_t length = 13;
const char* topic = "top";
uint8_t qos = 2;
bool retain = true;
const uint8_t payload[] = {0x01, 0x02, 0x03, 0x04};
uint16_t payloadLength = 4;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
packetId,
topic,
payload,
payloadLength,
qos,
retain);
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBLISH, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
const uint8_t checkDup[] = {
0b00111101, // header, dup, qos, retain
0x0B,
0x00,0x03,'t','o','p', // topic
0x00,0x16, // packet Id
0x01,0x02,0x03,0x04 // payload
};
packet.setDup();
TEST_ASSERT_EQUAL_UINT8_ARRAY(checkDup, packet.data(0), length);
}
void test_encodePubAck() {
const uint8_t check[] = {
0b01000000, // header
0x02,
0x00,0x16, // packet Id
};
const uint32_t length = 4;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, PacketType.PUBACK, packetId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBACK, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodePubRec() {
const uint8_t check[] = {
0b01010000, // header
0x02,
0x00,0x16, // packet Id
};
const uint32_t length = 4;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, PacketType.PUBREC, packetId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBREC, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodePubRel() {
const uint8_t check[] = {
0b01100010, // header
0x02,
0x00,0x16, // packet Id
};
const uint32_t length = 4;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, PacketType.PUBREL, packetId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBREL, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodePubComp() {
const uint8_t check[] = {
0b01110000, // header
0x02, // remaining length
0x00,0x16, // packet Id
};
const uint32_t length = 4;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, PacketType.PUBCOMP, packetId);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PUBCOMP, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodeSubscribe() {
const uint8_t check[] = {
0b10000010, // header
0x08, // remaining length
0x00,0x16, // packet Id
0x00, 0x03, 'a', '/', 'b', // topic
0x02 // qos
};
const uint32_t length = 10;
const char* topic = "a/b";
uint8_t qos = 2;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, packetId, topic, qos);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.SUBSCRIBE, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodeMultiSubscribe2() {
const uint8_t check[] = {
0b10000010, // header
0x0E, // remaining length
0x00,0x16, // packet Id
0x00, 0x03, 'a', '/', 'b', // topic1
0x01, // qos1
0x00, 0x03, 'c', '/', 'd', // topic2
0x02 // qos2
};
const uint32_t length = 16;
const char* topic1 = "a/b";
const char* topic2 = "c/d";
uint8_t qos1 = 1;
uint8_t qos2 = 2;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, packetId, topic1, qos1, topic2, qos2);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.SUBSCRIBE, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodeMultiSubscribe3() {
const uint8_t check[] = {
0b10000010, // header
0x14, // remaining length
0x00,0x16, // packet Id
0x00, 0x03, 'a', '/', 'b', // topic1
0x01, // qos1
0x00, 0x03, 'c', '/', 'd', // topic2
0x02, // qos2
0x00, 0x03, 'e', '/', 'f', // topic3
0x00 // qos3
};
const uint32_t length = 22;
const char* topic1 = "a/b";
const char* topic2 = "c/d";
const char* topic3 = "e/f";
uint8_t qos1 = 1;
uint8_t qos2 = 2;
uint8_t qos3 = 0;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, packetId, topic1, qos1, topic2, qos2, topic3, qos3);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.SUBSCRIBE, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodeUnsubscribe() {
const uint8_t check[] = {
0b10100010, // header
0x07, // remaining length
0x00,0x16, // packet Id
0x00, 0x03, 'a', '/', 'b', // topic
};
const uint32_t length = 9;
const char* topic = "a/b";
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, packetId, topic);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.UNSUBSCRIBE, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodeMultiUnsubscribe2() {
const uint8_t check[] = {
0b10100010, // header
0x0C, // remaining length
0x00,0x16, // packet Id
0x00, 0x03, 'a', '/', 'b', // topic1
0x00, 0x03, 'c', '/', 'd' // topic2
};
const uint32_t length = 14;
const char* topic1 = "a/b";
const char* topic2 = "c/d";
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, packetId, topic1, topic2);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.UNSUBSCRIBE, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodeMultiUnsubscribe3() {
const uint8_t check[] = {
0b10100010, // header
0x11, // remaining length
0x00,0x16, // packet Id
0x00, 0x03, 'a', '/', 'b', // topic1
0x00, 0x03, 'c', '/', 'd', // topic2
0x00, 0x03, 'e', '/', 'f', // topic3
};
const uint32_t length = 19;
const char* topic1 = "a/b";
const char* topic2 = "c/d";
const char* topic3 = "e/f";
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, packetId, topic1, topic2, topic3);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.UNSUBSCRIBE, packet.packetType());
TEST_ASSERT_FALSE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
}
void test_encodePingReq() {
const uint8_t check[] = {
0b11000000, // header
0x00
};
const uint32_t length = 2;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, PacketType.PINGREQ);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.PINGREQ, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(0, packet.packetId());
}
void test_encodeDisconnect() {
const uint8_t check[] = {
0b11100000, // header
0x00
};
const uint32_t length = 2;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error, PacketType.DISCONNECT);
packet.setDup(); // no effect
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(length, packet.size());
TEST_ASSERT_EQUAL_UINT8(PacketType.DISCONNECT, packet.packetType());
TEST_ASSERT_TRUE(packet.removable());
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(0), length);
TEST_ASSERT_EQUAL_UINT16(0, packet.packetId());
}
size_t getData(uint8_t* dest, size_t len, size_t index) {
(void) index;
static uint8_t i = 1;
memset(dest, i, len);
++i;
return len;
}
void test_encodeChunkedPublish() {
const uint8_t check[] = {
0b00110011, // header, dup, qos, retain
0xCF, 0x01, // 7 + 200 = (0x4F * 1) & 0x40 + (0x01 * 128)
0x00,0x03,'t','o','p', // topic
0x00,0x16 // packet Id
};
uint8_t payloadChunk[EMC_TX_BUFFER_SIZE] = {};
memset(payloadChunk, 0x01, EMC_TX_BUFFER_SIZE);
const char* topic = "top";
uint8_t qos = 1;
bool retain = true;
size_t headerLength = 10;
size_t payloadLength = 200;
size_t size = headerLength + payloadLength;
uint16_t packetId = 22;
espMqttClientTypes::Error error = espMqttClientTypes::Error::MISC_ERROR;
Packet packet(error,
packetId,
topic,
getData,
payloadLength,
qos,
retain);
TEST_ASSERT_EQUAL_UINT8(espMqttClientTypes::Error::SUCCESS, error);
TEST_ASSERT_EQUAL_UINT32(size, packet.size());
TEST_ASSERT_EQUAL_UINT16(packetId, packet.packetId());
size_t available = 0;
size_t index = 0;
// call 'available' before 'data'
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(headerLength + EMC_TX_BUFFER_SIZE, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, packet.data(index), headerLength);
// index == first payload byte
index = headerLength;
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(EMC_TX_BUFFER_SIZE, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(payloadChunk, packet.data(index), available);
// index == first payload byte
index = headerLength + 4;
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(EMC_TX_BUFFER_SIZE - 4, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(payloadChunk, packet.data(index), available);
// index == last payload byte in first chunk
index = headerLength + EMC_TX_BUFFER_SIZE - 1;
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(1, available);
// index == first payloadbyte in second chunk
memset(payloadChunk, 0x02, EMC_TX_BUFFER_SIZE);
index = headerLength + EMC_TX_BUFFER_SIZE;
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(EMC_TX_BUFFER_SIZE, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(payloadChunk, packet.data(index), available);
memset(payloadChunk, 0x03, EMC_TX_BUFFER_SIZE);
index = headerLength + EMC_TX_BUFFER_SIZE + EMC_TX_BUFFER_SIZE + 10;
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(EMC_TX_BUFFER_SIZE, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(payloadChunk, packet.data(index), available);
const uint8_t checkDup[] = {
0b00111011, // header, dup, qos, retain
0xCF, 0x01, // 7 + 200 = (0x4F * 0) + (0x01 * 128)
0x00,0x03,'t','o','p', // topic
0x00,0x16, // packet Id
};
index = 0;
packet.setDup();
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(headerLength + EMC_TX_BUFFER_SIZE, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(checkDup, packet.data(index), headerLength);
memset(payloadChunk, 0x04, EMC_TX_BUFFER_SIZE);
index = headerLength;
available = packet.available(index);
TEST_ASSERT_EQUAL_UINT32(EMC_TX_BUFFER_SIZE, available);
TEST_ASSERT_EQUAL_UINT8_ARRAY(payloadChunk, packet.data(index), available);
}
int main() {
UNITY_BEGIN();
RUN_TEST(test_encodeConnect0);
RUN_TEST(test_encodeConnect1);
RUN_TEST(test_encodeConnect2);
RUN_TEST(test_encodeConnectFail0);
RUN_TEST(test_encodePublish0);
RUN_TEST(test_encodePublish1);
RUN_TEST(test_encodePublish2);
RUN_TEST(test_encodePubAck);
RUN_TEST(test_encodePubRec);
RUN_TEST(test_encodePubRel);
RUN_TEST(test_encodePubComp);
RUN_TEST(test_encodeSubscribe);
RUN_TEST(test_encodeMultiSubscribe2);
RUN_TEST(test_encodeMultiSubscribe3);
RUN_TEST(test_encodeUnsubscribe);
RUN_TEST(test_encodeMultiUnsubscribe2);
RUN_TEST(test_encodeMultiUnsubscribe3);
RUN_TEST(test_encodePingReq);
RUN_TEST(test_encodeDisconnect);
RUN_TEST(test_encodeChunkedPublish);
return UNITY_END();
}

355
lib/espMqttClient/test/test_parser/test_parser.cpp Normal file
View File

@@ -0,0 +1,355 @@
#include <unity.h>
#include <Packets/Parser.h>
using espMqttClientInternals::Parser;
using espMqttClientInternals::ParserResult;
using espMqttClientInternals::IncomingPacket;
void setUp() {}
void tearDown() {}
Parser parser;
void test_Connack() {
const uint8_t stream[] = {
0b00100000, // header
0b00000010, // flags
0b00000001, // session present
0b00000000 // reserved
};
const size_t length = 4;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(4, bytesRead);
TEST_ASSERT_EQUAL_UINT8(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT8(1, parser.getPacket().variableHeader.fixed.connackVarHeader.sessionPresent);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().variableHeader.fixed.connackVarHeader.returnCode);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_Empty() {
const uint8_t stream[] = {
0x00
};
const size_t length = 0;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_UINT8(ParserResult::awaitData, result);
TEST_ASSERT_EQUAL_INT32(0, bytesRead);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_Header() {
const uint8_t stream[] = {
0x12,
0x13,
0x14
};
const size_t length = 3;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::protocolError, result);
TEST_ASSERT_EQUAL_UINT32(1, bytesRead);
}
void test_Publish() {
uint8_t stream[] = {
0b00110010, // header
0x0B, // remaining length
0x00, 0x03, 'a', '/', 'b', // topic
0x00, 0x0A, // packet id
0x01, 0x02 // payload
};
size_t length = 11;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBLISH, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_STRING("a/b", parser.getPacket().variableHeader.topic);
TEST_ASSERT_EQUAL_UINT16(10, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.index);
TEST_ASSERT_EQUAL_UINT32(2, parser.getPacket().payload.length);
TEST_ASSERT_EQUAL_UINT32(4, parser.getPacket().payload.total);
TEST_ASSERT_EQUAL_UINT8(1, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
stream[0] = 0x03;
stream[1] = 0x04;
length = 2;
bytesRead = 0;
result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_STRING("a/b", parser.getPacket().variableHeader.topic);
TEST_ASSERT_EQUAL_UINT16(10, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT32(2, parser.getPacket().payload.index);
TEST_ASSERT_EQUAL_UINT32(2, parser.getPacket().payload.length);
TEST_ASSERT_EQUAL_UINT32(4, parser.getPacket().payload.total);
TEST_ASSERT_EQUAL_UINT8(1, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_Publish_empty() {
uint8_t stream0[] = {
0b00110000, // header
0x05, // remaining length
0x00, 0x03, 'a', '/', 'b', // topic
};
size_t length0 = 7;
size_t bytesRead0 = 0;
ParserResult result0 = parser.parse(stream0, length0, &bytesRead0);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result0);
TEST_ASSERT_EQUAL_UINT32(length0, bytesRead0);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBLISH, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_STRING("a/b", parser.getPacket().variableHeader.topic);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.index);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.length);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.total);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
uint8_t stream1[] = {
0b00110000, // header
0x05, // remaining length
0x00, 0x03, 'a', '/', 'b', // topic
};
size_t length1 = 7;
size_t bytesRead1 = 0;
ParserResult result1 = parser.parse(stream1, length1, &bytesRead1);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result1);
TEST_ASSERT_EQUAL_UINT32(length1, bytesRead1);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBLISH, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_STRING("a/b", parser.getPacket().variableHeader.topic);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.index);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.length);
TEST_ASSERT_EQUAL_UINT32(0, parser.getPacket().payload.total);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_PubAck() {
const uint8_t stream[] = {
0b01000000,
0b00000010,
0x12,
0x34
};
const size_t length = 4;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBACK, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT16(4660, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_PubRec() {
const uint8_t stream[] = {
0b01010000,
0b00000010,
0x56,
0x78
};
const size_t length = 4;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_BITS(0xF0, espMqttClientInternals::PacketType.PUBREC, parser.getPacket().fixedHeader.packetType);
TEST_ASSERT_EQUAL_UINT16(22136, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_PubRel() {
const uint8_t stream[] = {
0b01100010,
0b00000010,
0x9A,
0xBC
};
const size_t length = 4;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBREL, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT16(0x9ABC, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_PubComp() {
const uint8_t stream[] = {
0b01110000,
0b00000010,
0xDE,
0xF0
};
const size_t length = 4;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBCOMP, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT16(0xDEF0, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_SubAck() {
const uint8_t stream[] = {
0b10010000,
0b00000100,
0x00,
0x0A,
0x02,
0x01
};
const size_t length = 6;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.SUBACK, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT16(10, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT8_ARRAY(&stream[4], parser.getPacket().payload.data,2);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_UnsubAck() {
const uint8_t stream[] = {
0b10110000,
0b00000010,
0x00,
0x0A
};
const size_t length = 4;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.UNSUBACK, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT16(10, parser.getPacket().variableHeader.fixed.packetId);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_PingResp() {
const uint8_t stream[] = {
0b11010000,
0x00
};
const size_t length = 2;
size_t bytesRead = 0;
ParserResult result = parser.parse(stream, length, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT32(length, bytesRead);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PINGRESP, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
void test_longStream() {
const uint8_t stream[] = {
0x90, 0x03, 0x00, 0x01, 0x00, 0x31, 0x0F, 0x00, 0x09, 0x66, 0x6F, 0x6F, 0x2F, 0x62, 0x61, 0x72,
0x2F, 0x30, 0x74, 0x65, 0x73, 0x74, 0x90, 0x03, 0x00, 0x02, 0x01, 0x33, 0x11, 0x00, 0x09, 0x66,
0x6F, 0x6F, 0x2F, 0x62, 0x61, 0x72, 0x2F, 0x31, 0x00, 0x01, 0x74, 0x65, 0x73, 0x74, 0x90, 0x03,
0x00, 0x03, 0x02, 0x30, 0x0F, 0x00, 0x09, 0x66, 0x6F, 0x6F, 0x2F, 0x62, 0x61, 0x72, 0x2F, 0x30,
0x74, 0x65, 0x73, 0x74, 0x32, 0x11, 0x00, 0x09, 0x66, 0x6F, 0x6F, 0x2F, 0x62, 0x61, 0x72, 0x2F,
0x31, 0x00, 0x02, 0x74, 0x65, 0x73, 0x74, 0x40, 0x02, 0x00, 0x04, 0x50, 0x02, 0x00, 0x05
};
const size_t length = 94;
size_t bytesRead = 0;
ParserResult result = parser.parse(&stream[bytesRead], length - bytesRead, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.SUBACK, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT32(5, bytesRead);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
result = parser.parse(&stream[bytesRead], length - bytesRead, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.PUBLISH, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT32(5 + 17, bytesRead);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_TRUE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
result = parser.parse(&stream[bytesRead], length - bytesRead, &bytesRead);
TEST_ASSERT_EQUAL_INT32(ParserResult::packet, result);
TEST_ASSERT_EQUAL_UINT8(espMqttClientInternals::PacketType.SUBACK, parser.getPacket().fixedHeader.packetType & 0xF0);
TEST_ASSERT_EQUAL_UINT32(5 + 17 + 5, bytesRead);
TEST_ASSERT_EQUAL_UINT8(0, parser.getPacket().qos());
TEST_ASSERT_FALSE(parser.getPacket().retain());
TEST_ASSERT_FALSE(parser.getPacket().dup());
}
int main() {
UNITY_BEGIN();
RUN_TEST(test_Connack);
RUN_TEST(test_Empty);
RUN_TEST(test_Header);
RUN_TEST(test_Publish);
RUN_TEST(test_Publish_empty);
RUN_TEST(test_PubAck);
RUN_TEST(test_PubRec);
RUN_TEST(test_PubRel);
RUN_TEST(test_PubComp);
RUN_TEST(test_SubAck);
RUN_TEST(test_UnsubAck);
RUN_TEST(test_PingResp);
RUN_TEST(test_longStream);
return UNITY_END();
}

63
lib/espMqttClient/test/test_remainingLength/test_remainingLength.cpp Normal file
View File

@@ -0,0 +1,63 @@
#include <iostream>
#include <unity.h>
#include <Packets/RemainingLength.h>
void setUp() {}
void tearDown() {}
// Examples takes from MQTT specification
uint8_t bytes1[] = {0x40};
uint8_t size1 = 1;
uint32_t length1 = 64;
uint8_t bytes2[] = {193, 2};
uint8_t size2 = 2;
uint32_t length2 = 321;
uint8_t bytes3[] = {0xff, 0xff, 0xff, 0x7f};
uint8_t size3 = 4;
uint32_t length3 = 268435455;
void test_remainingLengthDecode() {
TEST_ASSERT_EQUAL_INT32(length1, espMqttClientInternals::decodeRemainingLength(bytes1));
TEST_ASSERT_EQUAL_INT32(length2, espMqttClientInternals::decodeRemainingLength(bytes2));
uint8_t stream[] = {0x80, 0x80, 0x80, 0x01};
TEST_ASSERT_EQUAL_INT32(2097152 , espMqttClientInternals::decodeRemainingLength(stream));
TEST_ASSERT_EQUAL_INT32(length3, espMqttClientInternals::decodeRemainingLength(bytes3));
}
void test_remainingLengthEncode() {
uint8_t bytes[4];
TEST_ASSERT_EQUAL_UINT8(1, espMqttClientInternals::remainingLengthLength(0));
TEST_ASSERT_EQUAL_UINT8(size1, espMqttClientInternals::remainingLengthLength(length1));
TEST_ASSERT_EQUAL_UINT8(size1, espMqttClientInternals::encodeRemainingLength(length1, bytes));
TEST_ASSERT_EQUAL_UINT8_ARRAY(bytes1, bytes, size1);
TEST_ASSERT_EQUAL_UINT8(size2, espMqttClientInternals::remainingLengthLength(length2));
TEST_ASSERT_EQUAL_UINT8(size2, espMqttClientInternals::encodeRemainingLength(length2, bytes));
TEST_ASSERT_EQUAL_UINT8_ARRAY(bytes2, bytes, size2);
TEST_ASSERT_EQUAL_UINT8(size3, espMqttClientInternals::remainingLengthLength(length3));
TEST_ASSERT_EQUAL_UINT8(size3, espMqttClientInternals::encodeRemainingLength(length3, bytes));
TEST_ASSERT_EQUAL_UINT8_ARRAY(bytes3, bytes, size3);
}
void test_remainingLengthError() {
uint8_t bytes[] = {0xff, 0xff, 0xff, 0x80}; // high bit of last byte is 1
// this indicates a next byte is coming
// which is a violation of the spec
TEST_ASSERT_EQUAL_UINT8(0, espMqttClientInternals::remainingLengthLength(268435456));
TEST_ASSERT_EQUAL_INT32(-1, espMqttClientInternals::decodeRemainingLength(bytes));
}
int main() {
UNITY_BEGIN();
RUN_TEST(test_remainingLengthDecode);
RUN_TEST(test_remainingLengthEncode);
RUN_TEST(test_remainingLengthError);
return UNITY_END();
}

64
lib/espMqttClient/test/test_string/test_string.cpp Normal file
View File

@@ -0,0 +1,64 @@
#include <iostream>
#include <unity.h>
#include <Packets/String.h>
void setUp() {}
void tearDown() {}
void test_encodeString() {
const char test[] = "abcd";
uint8_t buffer[6];
const uint8_t check[] = {0x00, 0x04, 'a', 'b', 'c', 'd'};
const uint32_t length = 6;
TEST_ASSERT_EQUAL_UINT32(length, espMqttClientInternals::encodeString(test, buffer));
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, buffer, length);
}
void test_emtpyString() {
const char test[] = "";
uint8_t buffer[2];
const uint8_t check[] = {0x00, 0x00};
const uint32_t length = 2;
TEST_ASSERT_EQUAL_UINT32(length, espMqttClientInternals::encodeString(test, buffer));
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, buffer, length);
}
void test_longString() {
const size_t maxSize = 65535;
char test[maxSize + 1];
test[maxSize] = '\0';
memset(test, 'a', maxSize);
uint8_t buffer[maxSize + 3];
uint8_t check[maxSize + 2];
check[0] = 0xFF;
check[1] = 0xFF;
memset(&check[2], 'a', maxSize);
const uint32_t length = 2 + maxSize;
TEST_ASSERT_EQUAL_UINT32(length, espMqttClientInternals::encodeString(test, buffer));
TEST_ASSERT_EQUAL_UINT8_ARRAY(check, buffer, length);
}
void test_tooLongString() {
const size_t maxSize = 65535;
char test[maxSize + 2];
test[maxSize + 1] = '\0';
memset(test, 'a', maxSize + 1);
uint8_t buffer[maxSize + 4]; // extra 4 bytes for headroom: test progam, don't test test
const uint32_t length = 0;
TEST_ASSERT_EQUAL_UINT32(length, espMqttClientInternals::encodeString(test, buffer));
}
int main() {
UNITY_BEGIN();
RUN_TEST(test_encodeString);
RUN_TEST(test_emtpyString);
RUN_TEST(test_longString);
RUN_TEST(test_tooLongString);
return UNITY_END();
}