ESP-MQTT
This commit is contained in:
iranl
@@ -1,15 +0,0 @@
|
||||
set(COMPONENT_SRCDIRS
|
||||
"src"
|
||||
)
|
||||
|
||||
set(COMPONENT_ADD_INCLUDEDIRS
|
||||
"src"
|
||||
)
|
||||
|
||||
set(COMPONENT_REQUIRES
|
||||
"arduino-esp32"
|
||||
)
|
||||
|
||||
register_component()
|
||||
|
||||
target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)
|
||||
@@ -1,30 +0,0 @@
|
||||
menu "AsyncTCP Configuration"
|
||||
|
||||
choice ASYNC_TCP_RUNNING_CORE
|
||||
bool "Core on which AsyncTCP's thread is running"
|
||||
default ASYNC_TCP_RUN_CORE1
|
||||
help
|
||||
Select on which core AsyncTCP is running
|
||||
|
||||
config ASYNC_TCP_RUN_CORE0
|
||||
bool "CORE 0"
|
||||
config ASYNC_TCP_RUN_CORE1
|
||||
bool "CORE 1"
|
||||
config ASYNC_TCP_RUN_NO_AFFINITY
|
||||
bool "BOTH"
|
||||
|
||||
endchoice
|
||||
|
||||
config ASYNC_TCP_RUNNING_CORE
|
||||
int
|
||||
default 0 if ASYNC_TCP_RUN_CORE0
|
||||
default 1 if ASYNC_TCP_RUN_CORE1
|
||||
default -1 if ASYNC_TCP_RUN_NO_AFFINITY
|
||||
|
||||
config ASYNC_TCP_USE_WDT
|
||||
bool "Enable WDT for the AsyncTCP task"
|
||||
default "y"
|
||||
help
|
||||
Enable WDT for the AsyncTCP task, so it will trigger if a handler is locking the thread.
|
||||
|
||||
endmenu
|
||||
@@ -1,165 +0,0 @@
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
|
||||
This version of the GNU Lesser General Public License incorporates
|
||||
the terms and conditions of version 3 of the GNU General Public
|
||||
License, supplemented by the additional permissions listed below.
|
||||
|
||||
0. Additional Definitions.
|
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser
|
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU
|
||||
General Public License.
|
||||
|
||||
"The Library" refers to a covered work governed by this License,
|
||||
other than an Application or a Combined Work as defined below.
|
||||
|
||||
An "Application" is any work that makes use of an interface provided
|
||||
by the Library, but which is not otherwise based on the Library.
|
||||
Defining a subclass of a class defined by the Library is deemed a mode
|
||||
of using an interface provided by the Library.
|
||||
|
||||
A "Combined Work" is a work produced by combining or linking an
|
||||
Application with the Library. The particular version of the Library
|
||||
with which the Combined Work was made is also called the "Linked
|
||||
Version".
|
||||
|
||||
The "Minimal Corresponding Source" for a Combined Work means the
|
||||
Corresponding Source for the Combined Work, excluding any source code
|
||||
for portions of the Combined Work that, considered in isolation, are
|
||||
based on the Application, and not on the Linked Version.
|
||||
|
||||
The "Corresponding Application Code" for a Combined Work means the
|
||||
object code and/or source code for the Application, including any data
|
||||
and utility programs needed for reproducing the Combined Work from the
|
||||
Application, but excluding the System Libraries of the Combined Work.
|
||||
|
||||
1. Exception to Section 3 of the GNU GPL.
|
||||
|
||||
You may convey a covered work under sections 3 and 4 of this License
|
||||
without being bound by section 3 of the GNU GPL.
|
||||
|
||||
2. Conveying Modified Versions.
|
||||
|
||||
If you modify a copy of the Library, and, in your modifications, a
|
||||
facility refers to a function or data to be supplied by an Application
|
||||
that uses the facility (other than as an argument passed when the
|
||||
facility is invoked), then you may convey a copy of the modified
|
||||
version:
|
||||
|
||||
a) under this License, provided that you make a good faith effort to
|
||||
ensure that, in the event an Application does not supply the
|
||||
function or data, the facility still operates, and performs
|
||||
whatever part of its purpose remains meaningful, or
|
||||
|
||||
b) under the GNU GPL, with none of the additional permissions of
|
||||
this License applicable to that copy.
|
||||
|
||||
3. Object Code Incorporating Material from Library Header Files.
|
||||
|
||||
The object code form of an Application may incorporate material from
|
||||
a header file that is part of the Library. You may convey such object
|
||||
code under terms of your choice, provided that, if the incorporated
|
||||
material is not limited to numerical parameters, data structure
|
||||
layouts and accessors, or small macros, inline functions and templates
|
||||
(ten or fewer lines in length), you do both of the following:
|
||||
|
||||
a) Give prominent notice with each copy of the object code that the
|
||||
Library is used in it and that the Library and its use are
|
||||
covered by this License.
|
||||
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license
|
||||
document.
|
||||
|
||||
4. Combined Works.
|
||||
|
||||
You may convey a Combined Work under terms of your choice that,
|
||||
taken together, effectively do not restrict modification of the
|
||||
portions of the Library contained in the Combined Work and reverse
|
||||
engineering for debugging such modifications, if you also do each of
|
||||
the following:
|
||||
|
||||
a) Give prominent notice with each copy of the Combined Work that
|
||||
the Library is used in it and that the Library and its use are
|
||||
covered by this License.
|
||||
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license
|
||||
document.
|
||||
|
||||
c) For a Combined Work that displays copyright notices during
|
||||
execution, include the copyright notice for the Library among
|
||||
these notices, as well as a reference directing the user to the
|
||||
copies of the GNU GPL and this license document.
|
||||
|
||||
d) Do one of the following:
|
||||
|
||||
0) Convey the Minimal Corresponding Source under the terms of this
|
||||
License, and the Corresponding Application Code in a form
|
||||
suitable for, and under terms that permit, the user to
|
||||
recombine or relink the Application with a modified version of
|
||||
the Linked Version to produce a modified Combined Work, in the
|
||||
manner specified by section 6 of the GNU GPL for conveying
|
||||
Corresponding Source.
|
||||
|
||||
1) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (a) uses at run time
|
||||
a copy of the Library already present on the user's computer
|
||||
system, and (b) will operate properly with a modified version
|
||||
of the Library that is interface-compatible with the Linked
|
||||
Version.
|
||||
|
||||
e) Provide Installation Information, but only if you would otherwise
|
||||
be required to provide such information under section 6 of the
|
||||
GNU GPL, and only to the extent that such information is
|
||||
necessary to install and execute a modified version of the
|
||||
Combined Work produced by recombining or relinking the
|
||||
Application with a modified version of the Linked Version. (If
|
||||
you use option 4d0, the Installation Information must accompany
|
||||
the Minimal Corresponding Source and Corresponding Application
|
||||
Code. If you use option 4d1, you must provide the Installation
|
||||
Information in the manner specified by section 6 of the GNU GPL
|
||||
for conveying Corresponding Source.)
|
||||
|
||||
5. Combined Libraries.
|
||||
|
||||
You may place library facilities that are a work based on the
|
||||
Library side by side in a single library together with other library
|
||||
facilities that are not Applications and are not covered by this
|
||||
License, and convey such a combined library under terms of your
|
||||
choice, if you do both of the following:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work based
|
||||
on the Library, uncombined with any other library facilities,
|
||||
conveyed under the terms of this License.
|
||||
|
||||
b) Give prominent notice with the combined library that part of it
|
||||
is a work based on the Library, and explaining where to find the
|
||||
accompanying uncombined form of the same work.
|
||||
|
||||
6. Revised Versions of the GNU Lesser General Public License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions
|
||||
of the GNU Lesser General Public License from time to time. Such new
|
||||
versions will be similar in spirit to the present version, but may
|
||||
differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Library as you received it specifies that a certain numbered version
|
||||
of the GNU Lesser General Public License "or any later version"
|
||||
applies to it, you have the option of following the terms and
|
||||
conditions either of that published version or of any later version
|
||||
published by the Free Software Foundation. If the Library as you
|
||||
received it does not specify a version number of the GNU Lesser
|
||||
General Public License, you may choose any version of the GNU Lesser
|
||||
General Public License ever published by the Free Software Foundation.
|
||||
|
||||
If the Library as you received it specifies that a proxy can decide
|
||||
whether future versions of the GNU Lesser General Public License shall
|
||||
apply, that proxy's public statement of acceptance of any version is
|
||||
permanent authorization for you to choose that version for the
|
||||
Library.
|
||||
@@ -1,56 +0,0 @@
|
||||
# AsyncTCP
|
||||
|
||||
[](https://opensource.org/license/lgpl-3-0/)
|
||||
[](https://github.com/mathieucarbou/AsyncTCP/actions/workflows/ci.yml)
|
||||
[](https://registry.platformio.org/libraries/mathieucarbou/AsyncTCP)
|
||||
|
||||
A fork of the [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) library by [@me-no-dev](https://github.com/me-no-dev) for [ESPHome](https://esphome.io).
|
||||
|
||||
### Async TCP Library for ESP32 Arduino
|
||||
|
||||
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
|
||||
|
||||
This library is the base for [ESPAsyncWebServer](https://github.com/mathieucarbou/ESPAsyncWebServer)
|
||||
|
||||
## AsyncClient and AsyncServer
|
||||
|
||||
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
|
||||
|
||||
## Changes in this fork
|
||||
|
||||
- All improvements from [ESPHome fork](https://github.com/esphome/AsyncTCP)
|
||||
- Reverted back `library.properties` for Arduino IDE users
|
||||
- Arduino 3 / ESP-IDF 5 compatibility
|
||||
- IPv6 support
|
||||
|
||||
## Coordinates
|
||||
|
||||
```
|
||||
mathieucarbou/AsyncTCP @ ^3.2.4
|
||||
```
|
||||
|
||||
## Important recommendations
|
||||
|
||||
Most of the crashes are caused by improper configuration of the library for the project.
|
||||
Here are some recommendations to avoid them.
|
||||
|
||||
1. Set the running core to be on the same core of your application (usually core 1) `-D CONFIG_ASYNC_TCP_RUNNING_CORE=1`
|
||||
2. Set the stack size appropriately with `-D CONFIG_ASYNC_TCP_STACK_SIZE=16384`.
|
||||
The default value of `16384` might be too much for your project.
|
||||
You can look at the [MycilaTaskMonitor](https://oss.carbou.me/MycilaTaskMonitor) project to monitor the stack usage.
|
||||
3. You can change **if you know what you are doing** the task priority with `-D CONFIG_ASYNC_TCP_PRIORITY=10`.
|
||||
Default is `10`.
|
||||
4. You can increase the queue size with `-D CONFIG_ASYNC_TCP_QUEUE_SIZE=128`.
|
||||
Default is `64`.
|
||||
5. You can decrease the maximum ack time `-D CONFIG_ASYNC_TCP_MAX_ACK_TIME=3000`.
|
||||
Default is `5000`.
|
||||
|
||||
I personally use the following configuration in my projects:
|
||||
|
||||
```c++
|
||||
-D CONFIG_ASYNC_TCP_MAX_ACK_TIME=3000
|
||||
-D CONFIG_ASYNC_TCP_PRIORITY=10
|
||||
-D CONFIG_ASYNC_TCP_QUEUE_SIZE=128
|
||||
-D CONFIG_ASYNC_TCP_RUNNING_CORE=1
|
||||
-D CONFIG_ASYNC_TCP_STACK_SIZE=4096
|
||||
```
|
||||
@@ -1,25 +0,0 @@
|
||||
board_manager:
|
||||
additional_urls:
|
||||
- https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
|
||||
directories:
|
||||
builtin.libraries: ./src/
|
||||
build_cache:
|
||||
compilations_before_purge: 10
|
||||
ttl: 720h0m0s
|
||||
daemon:
|
||||
port: "50051"
|
||||
library:
|
||||
enable_unsafe_install: false
|
||||
logging:
|
||||
file: ""
|
||||
format: text
|
||||
level: info
|
||||
metrics:
|
||||
addr: :9090
|
||||
enabled: true
|
||||
output:
|
||||
no_color: false
|
||||
sketch:
|
||||
always_export_binaries: false
|
||||
updater:
|
||||
enable_notification: true
|
||||
@@ -1,25 +0,0 @@
|
||||
board_manager:
|
||||
additional_urls:
|
||||
- https://espressif.github.io/arduino-esp32/package_esp32_index.json
|
||||
directories:
|
||||
builtin.libraries: ./src/
|
||||
build_cache:
|
||||
compilations_before_purge: 10
|
||||
ttl: 720h0m0s
|
||||
daemon:
|
||||
port: "50051"
|
||||
library:
|
||||
enable_unsafe_install: false
|
||||
logging:
|
||||
file: ""
|
||||
format: text
|
||||
level: info
|
||||
metrics:
|
||||
addr: :9090
|
||||
enabled: true
|
||||
output:
|
||||
no_color: false
|
||||
sketch:
|
||||
always_export_binaries: false
|
||||
updater:
|
||||
enable_notification: true
|
||||
@@ -1,3 +0,0 @@
|
||||
COMPONENT_ADD_INCLUDEDIRS := src
|
||||
COMPONENT_SRCDIRS := src
|
||||
CXXFLAGS += -fno-rtti
|
||||
@@ -1,42 +0,0 @@
|
||||
#include <AsyncTCP.h>
|
||||
|
||||
#include "config.h"
|
||||
|
||||
static void replyToServer(void* arg) {
|
||||
AsyncClient* client = reinterpret_cast<AsyncClient*>(arg);
|
||||
|
||||
// send reply
|
||||
if (client->space() > 32 && client->canSend()) {
|
||||
char message[32];
|
||||
client->add(message, strlen(message));
|
||||
client->send();
|
||||
}
|
||||
}
|
||||
|
||||
/* event callbacks */
|
||||
static void handleData(void* arg, AsyncClient* client, void *data, size_t len) {
|
||||
Serial.printf("\n data received from %s \n", client->remoteIP().toString().c_str());
|
||||
Serial.write((uint8_t*)data, len);
|
||||
|
||||
}
|
||||
|
||||
void onConnect(void* arg, AsyncClient* client) {
|
||||
Serial.printf("\n client has been connected to %s on port %d \n", SERVER_HOST_NAME, TCP_PORT);
|
||||
replyToServer(client);
|
||||
}
|
||||
|
||||
|
||||
void setup() {
|
||||
Serial.begin(115200);
|
||||
delay(20);
|
||||
|
||||
AsyncClient* client = new AsyncClient;
|
||||
client->onData(&handleData, client);
|
||||
client->onConnect(&onConnect, client);
|
||||
client->connect(SERVER_HOST_NAME, TCP_PORT);
|
||||
|
||||
}
|
||||
|
||||
void loop() {
|
||||
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef CONFIG_H
|
||||
#define CONFIG_H
|
||||
|
||||
/*
|
||||
* This example demonstrate how to use asynchronous client & server APIs
|
||||
* in order to establish tcp socket connections in client server manner.
|
||||
* server is running (on port 7050) on one ESP, acts as AP, and other clients running on
|
||||
* remaining ESPs acts as STAs. after connection establishment between server and clients
|
||||
* there is a simple message transfer in every 2s. clients connect to server via it's host name
|
||||
* (in this case 'esp_server') with help of DNS service running on server side.
|
||||
*
|
||||
* Note: default MSS for ESPAsyncTCP is 536 byte and defualt ACK timeout is 5s.
|
||||
*/
|
||||
|
||||
#define SSID "ESP-TEST"
|
||||
#define PASSWORD "123456789"
|
||||
|
||||
#define SERVER_HOST_NAME "esp_server"
|
||||
|
||||
#define TCP_PORT 7050
|
||||
#define DNS_PORT 53
|
||||
|
||||
#endif // CONFIG_H
|
||||
@@ -1,38 +0,0 @@
|
||||
{
|
||||
"name": "AsyncTCP",
|
||||
"version": "3.2.4",
|
||||
"description": "Asynchronous TCP Library for ESP32",
|
||||
"keywords": "async,tcp",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/mathieucarbou/AsyncTCP.git"
|
||||
},
|
||||
"authors": [
|
||||
{
|
||||
"name": "Hristo Gochkov"
|
||||
},
|
||||
{
|
||||
"name": "Mathieu Carbou",
|
||||
"maintainer": true
|
||||
}
|
||||
],
|
||||
"license": "LGPL-3.0",
|
||||
"frameworks": "arduino",
|
||||
"platforms": [
|
||||
"espressif32",
|
||||
"libretiny"
|
||||
],
|
||||
"build": {
|
||||
"libCompatMode": 2
|
||||
},
|
||||
"export": {
|
||||
"include": [
|
||||
"examples",
|
||||
"src",
|
||||
"library.json",
|
||||
"library.properties",
|
||||
"LICENSE",
|
||||
"README.md"
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
name=AsyncTCP
|
||||
version=3.2.4
|
||||
author=Me-No-Dev
|
||||
maintainer=Mathieu Carbou <mathieu.carbou@gmail.com>
|
||||
sentence=Async TCP Library for ESP32
|
||||
paragraph=Async TCP Library for ESP32
|
||||
category=Other
|
||||
url=https://github.com/mathieucarbou/AsyncTCP.git
|
||||
architectures=*
|
||||
@@ -1,48 +0,0 @@
|
||||
[env]
|
||||
framework = arduino
|
||||
build_flags =
|
||||
-Wall -Wextra
|
||||
-D CONFIG_ARDUHAL_LOG_COLORS
|
||||
-D CORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
|
||||
upload_protocol = esptool
|
||||
monitor_speed = 115200
|
||||
monitor_filters = esp32_exception_decoder, log2file
|
||||
|
||||
[platformio]
|
||||
lib_dir = .
|
||||
src_dir = examples/ClientServer/Client
|
||||
|
||||
[env:arduino]
|
||||
platform = espressif32
|
||||
board = esp32dev
|
||||
|
||||
[env:arduino-2]
|
||||
platform = espressif32@6.7.0
|
||||
board = esp32dev
|
||||
|
||||
[env:arduino-3]
|
||||
platform = espressif32
|
||||
platform_packages=
|
||||
platformio/framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#3.0.3
|
||||
platformio/framework-arduinoespressif32-libs @ https://github.com/espressif/arduino-esp32/releases/download/3.0.3/esp32-arduino-libs-3.0.3.zip
|
||||
board = esp32dev
|
||||
|
||||
[env:pioarduino-esp32dev]
|
||||
platform = https://github.com/pioarduino/platform-espressif32/releases/download/51.03.03/platform-espressif32.zip
|
||||
board = esp32dev
|
||||
|
||||
[env:pioarduino-esp32-s2]
|
||||
platform = https://github.com/pioarduino/platform-espressif32/releases/download/51.03.03/platform-espressif32.zip
|
||||
board = esp32-s2-saola-1
|
||||
|
||||
[env:pioarduino-esp32-s3]
|
||||
platform = https://github.com/pioarduino/platform-espressif32/releases/download/51.03.03/platform-espressif32.zip
|
||||
board = esp32-s3-devkitc-1
|
||||
|
||||
[env:pioarduino-esp32-c3]
|
||||
platform = https://github.com/pioarduino/platform-espressif32/releases/download/51.03.03/platform-espressif32.zip
|
||||
board = esp32-c3-devkitc-02
|
||||
|
||||
[env:pioarduino-esp32-c6]
|
||||
platform = https://github.com/pioarduino/platform-espressif32/releases/download/51.03.03/platform-espressif32.zip
|
||||
board = esp32-c6-devkitc-1
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,279 +0,0 @@
|
||||
/*
|
||||
Asynchronous TCP library for Espressif MCUs
|
||||
|
||||
Copyright (c) 2016 Hristo Gochkov. All rights reserved.
|
||||
This file is part of the esp8266 core for Arduino environment.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef ASYNCTCP_H_
|
||||
#define ASYNCTCP_H_
|
||||
|
||||
#define ASYNCTCP_VERSION "3.2.4"
|
||||
#define ASYNCTCP_VERSION_MAJOR 3
|
||||
#define ASYNCTCP_VERSION_MINOR 2
|
||||
#define ASYNCTCP_VERSION_REVISION 4
|
||||
#define ASYNCTCP_FORK_mathieucarbou
|
||||
|
||||
#include "IPAddress.h"
|
||||
#if ESP_IDF_VERSION_MAJOR < 5
|
||||
#include "IPv6Address.h"
|
||||
#endif
|
||||
#include <functional>
|
||||
#include "lwip/ip_addr.h"
|
||||
#include "lwip/ip6_addr.h"
|
||||
|
||||
#ifndef LIBRETINY
|
||||
#include "sdkconfig.h"
|
||||
extern "C" {
|
||||
#include "freertos/semphr.h"
|
||||
#include "lwip/pbuf.h"
|
||||
}
|
||||
#else
|
||||
extern "C" {
|
||||
#include <semphr.h>
|
||||
#include <lwip/pbuf.h>
|
||||
}
|
||||
#define CONFIG_ASYNC_TCP_RUNNING_CORE -1 //any available core
|
||||
#define CONFIG_ASYNC_TCP_USE_WDT 0
|
||||
#endif
|
||||
|
||||
//If core is not defined, then we are running in Arduino or PIO
|
||||
#ifndef CONFIG_ASYNC_TCP_RUNNING_CORE
|
||||
#define CONFIG_ASYNC_TCP_RUNNING_CORE -1 //any available core
|
||||
#define CONFIG_ASYNC_TCP_USE_WDT 1 //if enabled, adds between 33us and 200us per event
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ASYNC_TCP_STACK_SIZE
|
||||
#define CONFIG_ASYNC_TCP_STACK_SIZE 8192 * 2
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ASYNC_TCP_PRIORITY
|
||||
#define CONFIG_ASYNC_TCP_PRIORITY 10
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ASYNC_TCP_QUEUE_SIZE
|
||||
#define CONFIG_ASYNC_TCP_QUEUE_SIZE 64
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ASYNC_TCP_MAX_ACK_TIME
|
||||
#define CONFIG_ASYNC_TCP_MAX_ACK_TIME 5000
|
||||
#endif
|
||||
|
||||
class AsyncClient;
|
||||
|
||||
#define ASYNC_WRITE_FLAG_COPY 0x01 //will allocate new buffer to hold the data while sending (else will hold reference to the data given)
|
||||
#define ASYNC_WRITE_FLAG_MORE 0x02 //will not send PSH flag, meaning that there should be more data to be sent before the application should react.
|
||||
|
||||
typedef std::function<void(void*, AsyncClient*)> AcConnectHandler;
|
||||
typedef std::function<void(void*, AsyncClient*, size_t len, uint32_t time)> AcAckHandler;
|
||||
typedef std::function<void(void*, AsyncClient*, int8_t error)> AcErrorHandler;
|
||||
typedef std::function<void(void*, AsyncClient*, void *data, size_t len)> AcDataHandler;
|
||||
typedef std::function<void(void*, AsyncClient*, struct pbuf *pb)> AcPacketHandler;
|
||||
typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler;
|
||||
|
||||
struct tcp_pcb;
|
||||
struct ip_addr;
|
||||
|
||||
class AsyncClient {
|
||||
public:
|
||||
AsyncClient(tcp_pcb* pcb = 0);
|
||||
~AsyncClient();
|
||||
|
||||
AsyncClient & operator=(const AsyncClient &other);
|
||||
AsyncClient & operator+=(const AsyncClient &other);
|
||||
|
||||
bool operator==(const AsyncClient &other);
|
||||
|
||||
bool operator!=(const AsyncClient &other) {
|
||||
return !(*this == other);
|
||||
}
|
||||
bool connect(const IPAddress& ip, uint16_t port);
|
||||
#if ESP_IDF_VERSION_MAJOR < 5
|
||||
bool connect(const IPv6Address& ip, uint16_t port);
|
||||
#endif
|
||||
bool connect(const char *host, uint16_t port);
|
||||
void close(bool now = false);
|
||||
void stop();
|
||||
int8_t abort();
|
||||
bool free();
|
||||
|
||||
bool canSend();//ack is not pending
|
||||
size_t space();//space available in the TCP window
|
||||
size_t add(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY);//add for sending
|
||||
bool send();//send all data added with the method above
|
||||
|
||||
//write equals add()+send()
|
||||
size_t write(const char* data);
|
||||
size_t write(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY); //only when canSend() == true
|
||||
|
||||
uint8_t state();
|
||||
bool connecting();
|
||||
bool connected();
|
||||
bool disconnecting();
|
||||
bool disconnected();
|
||||
bool freeable();//disconnected or disconnecting
|
||||
|
||||
uint16_t getMss();
|
||||
|
||||
uint32_t getRxTimeout();
|
||||
void setRxTimeout(uint32_t timeout);//no RX data timeout for the connection in seconds
|
||||
|
||||
uint32_t getAckTimeout();
|
||||
void setAckTimeout(uint32_t timeout);//no ACK timeout for the last sent packet in milliseconds
|
||||
|
||||
void setNoDelay(bool nodelay);
|
||||
bool getNoDelay();
|
||||
|
||||
void setKeepAlive(uint32_t ms, uint8_t cnt);
|
||||
|
||||
uint32_t getRemoteAddress();
|
||||
uint16_t getRemotePort();
|
||||
uint32_t getLocalAddress();
|
||||
uint16_t getLocalPort();
|
||||
#if LWIP_IPV6
|
||||
ip6_addr_t getRemoteAddress6();
|
||||
ip6_addr_t getLocalAddress6();
|
||||
#if ESP_IDF_VERSION_MAJOR < 5
|
||||
IPv6Address remoteIP6();
|
||||
IPv6Address localIP6();
|
||||
#else
|
||||
IPAddress remoteIP6();
|
||||
IPAddress localIP6();
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//compatibility
|
||||
IPAddress remoteIP();
|
||||
uint16_t remotePort();
|
||||
IPAddress localIP();
|
||||
uint16_t localPort();
|
||||
|
||||
void onConnect(AcConnectHandler cb, void* arg = 0); //on successful connect
|
||||
void onDisconnect(AcConnectHandler cb, void* arg = 0); //disconnected
|
||||
void onAck(AcAckHandler cb, void* arg = 0); //ack received
|
||||
void onError(AcErrorHandler cb, void* arg = 0); //unsuccessful connect or error
|
||||
void onData(AcDataHandler cb, void* arg = 0); //data received (called if onPacket is not used)
|
||||
void onPacket(AcPacketHandler cb, void* arg = 0); //data received
|
||||
void onTimeout(AcTimeoutHandler cb, void* arg = 0); //ack timeout
|
||||
void onPoll(AcConnectHandler cb, void* arg = 0); //every 125ms when connected
|
||||
|
||||
void ackPacket(struct pbuf * pb);//ack pbuf from onPacket
|
||||
size_t ack(size_t len); //ack data that you have not acked using the method below
|
||||
void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData
|
||||
|
||||
const char * errorToString(int8_t error);
|
||||
const char * stateToString();
|
||||
|
||||
//Do not use any of the functions below!
|
||||
static int8_t _s_poll(void *arg, struct tcp_pcb *tpcb);
|
||||
static int8_t _s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, int8_t err);
|
||||
static int8_t _s_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
|
||||
static int8_t _s_lwip_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
|
||||
static void _s_error(void *arg, int8_t err);
|
||||
static int8_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len);
|
||||
static int8_t _s_connected(void* arg, struct tcp_pcb *tpcb, int8_t err);
|
||||
static void _s_dns_found(const char *name, struct ip_addr *ipaddr, void *arg);
|
||||
|
||||
int8_t _recv(tcp_pcb* pcb, pbuf* pb, int8_t err);
|
||||
tcp_pcb * pcb(){ return _pcb; }
|
||||
|
||||
protected:
|
||||
bool _connect(ip_addr_t addr, uint16_t port);
|
||||
|
||||
tcp_pcb* _pcb;
|
||||
int8_t _closed_slot;
|
||||
|
||||
AcConnectHandler _connect_cb;
|
||||
void* _connect_cb_arg;
|
||||
AcConnectHandler _discard_cb;
|
||||
void* _discard_cb_arg;
|
||||
AcAckHandler _sent_cb;
|
||||
void* _sent_cb_arg;
|
||||
AcErrorHandler _error_cb;
|
||||
void* _error_cb_arg;
|
||||
AcDataHandler _recv_cb;
|
||||
void* _recv_cb_arg;
|
||||
AcPacketHandler _pb_cb;
|
||||
void* _pb_cb_arg;
|
||||
AcTimeoutHandler _timeout_cb;
|
||||
void* _timeout_cb_arg;
|
||||
AcConnectHandler _poll_cb;
|
||||
void* _poll_cb_arg;
|
||||
|
||||
bool _ack_pcb;
|
||||
uint32_t _tx_last_packet;
|
||||
uint32_t _rx_ack_len;
|
||||
uint32_t _rx_last_packet;
|
||||
uint32_t _rx_timeout;
|
||||
uint32_t _rx_last_ack;
|
||||
uint32_t _ack_timeout;
|
||||
uint16_t _connect_port;
|
||||
|
||||
int8_t _close();
|
||||
void _free_closed_slot();
|
||||
bool _allocate_closed_slot();
|
||||
int8_t _connected(tcp_pcb* pcb, int8_t err);
|
||||
void _error(int8_t err);
|
||||
int8_t _poll(tcp_pcb* pcb);
|
||||
int8_t _sent(tcp_pcb* pcb, uint16_t len);
|
||||
int8_t _fin(tcp_pcb* pcb, int8_t err);
|
||||
int8_t _lwip_fin(tcp_pcb* pcb, int8_t err);
|
||||
void _dns_found(struct ip_addr *ipaddr);
|
||||
|
||||
public:
|
||||
AsyncClient* prev;
|
||||
AsyncClient* next;
|
||||
};
|
||||
|
||||
class AsyncServer {
|
||||
public:
|
||||
AsyncServer(IPAddress addr, uint16_t port);
|
||||
#if ESP_IDF_VERSION_MAJOR < 5
|
||||
AsyncServer(IPv6Address addr, uint16_t port);
|
||||
#endif
|
||||
AsyncServer(uint16_t port);
|
||||
~AsyncServer();
|
||||
void onClient(AcConnectHandler cb, void* arg);
|
||||
void begin();
|
||||
void end();
|
||||
void setNoDelay(bool nodelay);
|
||||
bool getNoDelay();
|
||||
uint8_t status();
|
||||
|
||||
//Do not use any of the functions below!
|
||||
static int8_t _s_accept(void *arg, tcp_pcb* newpcb, int8_t err);
|
||||
static int8_t _s_accepted(void *arg, AsyncClient* client);
|
||||
|
||||
protected:
|
||||
uint16_t _port;
|
||||
bool _bind4 = false;
|
||||
bool _bind6 = false;
|
||||
IPAddress _addr;
|
||||
#if ESP_IDF_VERSION_MAJOR < 5
|
||||
IPv6Address _addr6;
|
||||
#endif
|
||||
bool _noDelay;
|
||||
tcp_pcb* _pcb;
|
||||
AcConnectHandler _connect_cb;
|
||||
void* _connect_cb_arg;
|
||||
|
||||
int8_t _accept(tcp_pcb* newpcb, int8_t err);
|
||||
int8_t _accepted(AsyncClient* client);
|
||||
};
|
||||
|
||||
|
||||
#endif /* ASYNCTCP_H_ */
|
||||
@@ -7,7 +7,7 @@ MqttLogger::MqttLogger(MqttLoggerMode mode)
|
||||
this->setBufferSize(MQTT_MAX_PACKET_SIZE);
|
||||
}
|
||||
|
||||
MqttLogger::MqttLogger(MqttClient& client, const char* topic, MqttLoggerMode mode)
|
||||
MqttLogger::MqttLogger(esp_mqtt_client_handle_t client, const char* topic, MqttLoggerMode mode)
|
||||
{
|
||||
this->setClient(client);
|
||||
this->setTopic(topic);
|
||||
@@ -19,9 +19,9 @@ MqttLogger::~MqttLogger()
|
||||
{
|
||||
}
|
||||
|
||||
void MqttLogger::setClient(MqttClient& client)
|
||||
void MqttLogger::setClient(esp_mqtt_client_handle_t client)
|
||||
{
|
||||
this->client = &client;
|
||||
this->client = client;
|
||||
}
|
||||
|
||||
void MqttLogger::setTopic(const char* topic)
|
||||
@@ -69,21 +69,22 @@ boolean MqttLogger::setBufferSize(uint16_t size)
|
||||
}
|
||||
|
||||
// send & reset current buffer
|
||||
void MqttLogger::sendBuffer()
|
||||
void MqttLogger::sendBuffer()
|
||||
{
|
||||
if (this->bufferCnt > 0)
|
||||
{
|
||||
bool doSerial = this->mode==MqttLoggerMode::SerialOnly || this->mode==MqttLoggerMode::MqttAndSerial || this->mode==MqttLoggerMode::MqttAndSerialAndWeb || this->mode==MqttLoggerMode::SerialAndWeb;
|
||||
bool doWebSerial = this->mode==MqttLoggerMode::MqttAndSerialAndWeb || this->mode==MqttLoggerMode::SerialAndWeb;
|
||||
|
||||
if (this->mode!=MqttLoggerMode::SerialOnly && this->mode!=MqttLoggerMode::SerialAndWeb && this->client != NULL && this->client->connected())
|
||||
|
||||
if (this->mode!=MqttLoggerMode::SerialOnly && this->mode!=MqttLoggerMode::SerialAndWeb && this->client != NULL)
|
||||
{
|
||||
this->client->publish(topic, 0, true, this->buffer, this->bufferCnt);
|
||||
} else if (this->mode == MqttLoggerMode::MqttAndSerialFallback)
|
||||
esp_mqtt_client_publish(this->client, topic, (const char*)this->buffer, this->bufferCnt, 0, 1);
|
||||
}
|
||||
else if (this->mode == MqttLoggerMode::MqttAndSerialFallback)
|
||||
{
|
||||
doSerial = true;
|
||||
}
|
||||
if (doSerial)
|
||||
if (doSerial)
|
||||
{
|
||||
Serial.write(this->buffer, this->bufferCnt);
|
||||
Serial.println();
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <Print.h>
|
||||
#include <espMqttClient.h>
|
||||
#include <mqtt_client.h>
|
||||
//#include "MycilaWebSerial.h"
|
||||
|
||||
#define MQTT_MAX_PACKET_SIZE 1024
|
||||
@@ -32,16 +32,16 @@ private:
|
||||
uint8_t* buffer;
|
||||
uint8_t* bufferEnd;
|
||||
uint16_t bufferCnt = 0, bufferSize = 0;
|
||||
MqttClient* client;
|
||||
esp_mqtt_client_handle_t client;
|
||||
MqttLoggerMode mode;
|
||||
void sendBuffer();
|
||||
|
||||
public:
|
||||
MqttLogger(MqttLoggerMode mode=MqttLoggerMode::MqttAndSerialFallback);
|
||||
MqttLogger(MqttClient& client, const char* topic, MqttLoggerMode mode=MqttLoggerMode::MqttAndSerialFallback);
|
||||
MqttLogger(esp_mqtt_client_handle_t client, const char* topic, MqttLoggerMode mode=MqttLoggerMode::MqttAndSerialFallback);
|
||||
~MqttLogger();
|
||||
|
||||
void setClient(MqttClient& client);
|
||||
void setClient(esp_mqtt_client_handle_t client);
|
||||
void setTopic(const char* topic);
|
||||
void setMode(MqttLoggerMode mode);
|
||||
void setRetained(boolean retained);
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
set(COMPONENT_SRCDIRS
|
||||
"src" "src/Packets" "src/Transport"
|
||||
)
|
||||
|
||||
set(COMPONENT_ADD_INCLUDEDIRS
|
||||
"src" "src/Packets" "src/Transport"
|
||||
)
|
||||
|
||||
set(COMPONENT_REQUIRES
|
||||
"arduino-esp32"
|
||||
"AsyncTCP"
|
||||
)
|
||||
|
||||
register_component()
|
||||
|
||||
target_compile_definitions(${COMPONENT_TARGET} PUBLIC -DESP32)
|
||||
target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)
|
||||
@@ -1,21 +0,0 @@
|
||||
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.
|
||||
@@ -1,61 +0,0 @@
|
||||
# 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.
|
||||
|
||||
|
||||
|
||||
|
||||
[](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
|
||||
- Espressif ESP32 using the ESP IDF, see [esp idf component](https://docs.espressif.com/projects/arduino-esp32/en/latest/esp-idf_component.html)
|
||||
- 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 `ClientPosixIPAddress` class. These are lacking many features needed for proper Linux support.
|
||||
|
||||
## Dependencies
|
||||
|
||||
This libraries requires [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) and [ESPAsnycTCP](https://github.com/me-no-dev/ESPAsyncTCP). These libraries are not actively maintained and have some bugs. There are alternatives available on Github but make sure these alternatives fit in your project.
|
||||
|
||||
Because of this, I have removed the explicit dependency. You will have to manually add the libraries so you can choose the version which best suites your code.
|
||||
|
||||
# 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).
|
||||
@@ -1,3 +0,0 @@
|
||||
COMPONENT_ADD_INCLUDEDIRS := src
|
||||
COMPONENT_SRCDIRS := src
|
||||
CXXFLAGS += -fno-rtti
|
||||
@@ -1,6 +0,0 @@
|
||||
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
|
||||
@@ -1,587 +0,0 @@
|
||||
|
||||
|
||||
|
||||
[](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
|
||||
- Espressif ESP32 using the ESP IDF, see [esp idf component](https://docs.espressif.com/projects/arduino-esp32/en/latest/esp-idf_component.html)
|
||||
- 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.
|
||||
|
||||
## Dependencies
|
||||
|
||||
This libraries requires [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) and [ESPAsnycTCP](https://github.com/me-no-dev/ESPAsyncTCP). These libraries are not actively maintained and have some bugs. There are alternatives available on Github but make sure these alternatives fit in your project.
|
||||
|
||||
Because of this, I have removed the explicit dependency. You will have to manually add the libraries so you can choose the version which best suites your code.
|
||||
|
||||
# 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, three optional parameters are available: `espMqttClient(bool internalTask = true, uint8_t priority = 1, uint8_t core = 1)`. By default, espMqttclient creates its own task to manage TCP. By setting `internalTask` to false, no task will be created and you will be responsible yourself to call `espMqttClient.loop()`. `priority` changes 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
|
||||
|
||||
```cpp
|
||||
espMqttClient& setTimeout(uint16_t timeout)
|
||||
```
|
||||
|
||||
Set the timeout for packets that need acknowledgement. Defaults to 10 seconds.
|
||||
When no acknowledgement has been received from the broker after sending a packet, the client will retransmit **all** the packets in the queue.
|
||||
|
||||
* **`timeout`**: Timeout in seconds
|
||||
|
||||
#### 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 `true` if the client is currently fully connected to the broker. During connecting or disconnecting, it will return `false`.
|
||||
|
||||
```cpp
|
||||
bool disconnected()
|
||||
```
|
||||
|
||||
Returns `true` if the client is currently disconnected from the broker. During disconnecting or connecting, it will return `false`.
|
||||
|
||||
```cpp
|
||||
bool connect()
|
||||
```
|
||||
|
||||
Start the connect procedure. Returns `true` if successful. A positive return value doesn not mean the client is already connected.
|
||||
|
||||
```cpp
|
||||
bool disconnect(bool force = false)
|
||||
```
|
||||
|
||||
Start the disconnect procedure, return `true` if successful. A positive return value doesn not mean the client is already disconnected.
|
||||
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(bool deleteSessionData = false)
|
||||
```
|
||||
|
||||
Clears all queued messages.
|
||||
Keep in mind that this may also delete any session data and therefore is not MQTT compliant.
|
||||
|
||||
- **`deleteSessionData`**: When true, delete all outgoing messages. Not 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 you have to call this function yourself **only if you have disabled the internal task** (see the constructors).
|
||||
|
||||
```cpp
|
||||
const char* getClientId() const
|
||||
```
|
||||
|
||||
Retuns the client ID.
|
||||
|
||||
```cpp
|
||||
size_t queueSize();
|
||||
```
|
||||
|
||||
Returns the amount of elements, regardless of type, in the queue.
|
||||
|
||||
# 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_TX_TIMEOUT 10000
|
||||
|
||||
Timeout in milliseconds before a (qos > 0) message will be retransmitted.
|
||||
|
||||
### 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.
|
||||
Regardless of this setting, after you called `disconnect()`, no messages can be published until fully disconnected.
|
||||
|
||||
### EMC_WAIT_FOR_CONNACK 1
|
||||
|
||||
espMqttClient waits for the CONNACK (connection acknowledge) packet before starting to send other packets.
|
||||
The MQTT specification allows to start sending before the broker acknowledges the connection but some brokers
|
||||
don't allow this (AWS for example doesn't).
|
||||
|
||||
### 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 5120
|
||||
|
||||
Only used on ESP32. Sets the stack size (in words) of the MQTT client worker task.
|
||||
|
||||
### EMC_MULTIPLE_CALLBACKS
|
||||
|
||||
This macro is by default not enabled so you can add a single callbacks to an event. Assigning a second will overwrite the existing callback. When enabling multiple callbacks, multiple callbacks (with uint32_t id) can be assigned. Removing is done by referencing the id.
|
||||
|
||||
### 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.
|
||||
|
||||
### EMC_USE_MEMPOOL 0
|
||||
|
||||
**Experimental**
|
||||
|
||||
When set to `1`, (outgoing) MQTT packets and the outbox data is stored in a memory pool. The memory pool is part of the espMqttClient object and is thus allocated in the same memory type. There are two pools: one to hold the outgoing packets (dynamic size elements) and one for the outbox itself (fixed-size elements).
|
||||
|
||||
#### EMC_NUM_POOL_ELEMENTS 32
|
||||
|
||||
This config variable is only used when enabling the memory pool. It defines
|
||||
- the number of elements in the outbox-pool
|
||||
- the number of blocks that will be allocated in the packet-pool
|
||||
|
||||
#### EMC_SIZE_POOL_ELEMENTS 128
|
||||
|
||||
This defines the size of one packet-pool element. Together with `EMC_NUM_POOL_ELEMENTS`, you get the total packet-pool size.
|
||||
The packet-pool can hold any size of element. The configuration only guarantees a minimum of `EMC_NUM_POOL_ELEMENTS` of size `EMC_SIZE_POOL_ELEMENTS` can fit in the pool.
|
||||
|
||||
### 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);
|
||||
```
|
||||
|
||||
### onMessage callbacks per topic
|
||||
|
||||
espMqttClient allows only one callback for incoming messages. You might want to have specific ones per topic. This example shows one way on how to achieve this.
|
||||
|
||||
Limitations of this code sample: only the first match is served and no wildcard topics allowed.
|
||||
|
||||
```cpp
|
||||
#include <map>
|
||||
#include <cstring>
|
||||
|
||||
// definitions of the std::map where we will store the topic/callback combinations
|
||||
struct MatchTopic {
|
||||
bool operator()(const char* a, const char* b) const {
|
||||
return strcmp(a, b) < 0;
|
||||
}
|
||||
};
|
||||
std::map<const char*, espMqttClientTypes::OnMessageCallback, MatchTopic> topicCallbacks;
|
||||
|
||||
// callbacks per topic
|
||||
void onTopic1(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
|
||||
// received a packet on topic 1
|
||||
}
|
||||
void onTopic2(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
|
||||
// received a packet on topic 2
|
||||
}
|
||||
|
||||
// general callback to dispatch to specific handlers
|
||||
void onMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
|
||||
auto it = topicCallbacks.find(topic);
|
||||
if (it != topicCallbacks.end()) {
|
||||
// if found, run specific callback
|
||||
(it->second)(properties, topic, payload, len, index, total);
|
||||
} else {
|
||||
// or handle it here
|
||||
}
|
||||
}
|
||||
|
||||
// in your Arduino setup() function:
|
||||
topicCallbacks.emplace("base/topic1", onTopic1);
|
||||
topicCallbacks.emplace("base/topic2", onTopic2);
|
||||
|
||||
mqttClient.onMessage(onMessage);
|
||||
```
|
||||
Binary file not shown.
@@ -1,106 +0,0 @@
|
||||
#include <ESP8266WiFi.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
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...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
|
||||
(void) event;
|
||||
Serial.println("Connected to Wi-Fi.");
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
|
||||
(void) event;
|
||||
Serial.println("Disconnected from Wi-Fi.");
|
||||
}
|
||||
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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.setAutoConnect(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
mqttClient.loop();
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,148 +0,0 @@
|
||||
#include <WiFi.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(espMqttClientTypes::UseInternalTask::NO);
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void WiFiEvent(WiFiEvent_t event) {
|
||||
Serial.printf("[WiFi-event] event: %d\n", event);
|
||||
switch(event) {
|
||||
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
|
||||
Serial.println("WiFi connected");
|
||||
Serial.println("IP address: ");
|
||||
Serial.println(WiFi.localIP());
|
||||
connectToMqtt();
|
||||
break;
|
||||
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
|
||||
Serial.println("WiFi lost connection");
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.persistent(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
// We used to option not to use the internal task
|
||||
// so we need to call the loop-method ourselves.
|
||||
// During connecting it may block.
|
||||
// Creating a separate task yourself is obviously
|
||||
// also a possibility.
|
||||
mqttClient.loop();
|
||||
}
|
||||
@@ -1,159 +0,0 @@
|
||||
#include <ESP8266WiFi.h>
|
||||
#include <Updater.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
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...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
|
||||
(void) event;
|
||||
Serial.println("Connected to Wi-Fi.");
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
|
||||
(void) event;
|
||||
Serial.println("Disconnected from Wi-Fi.");
|
||||
}
|
||||
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) properties;
|
||||
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();
|
||||
|
||||
WiFi.setAutoConnect(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
if (restartFlag) {
|
||||
Serial.println("Rebooting... See you next time!");
|
||||
Serial.flush();
|
||||
ESP.reset();
|
||||
}
|
||||
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
mqttClient.loop();
|
||||
|
||||
if (!disconnectFlag && reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
if (disconnectFlag) {
|
||||
// it's safe to call this multiple times
|
||||
mqttClient.disconnect();
|
||||
}
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
# The following lines of boilerplate have to be in your project's
|
||||
# CMakeLists in this exact order for cmake to work correctly
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
SET(SDKCONFIG ${CMAKE_BINARY_DIR}/sdkconfig)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(simple-esp32-idf)
|
||||
@@ -1,3 +0,0 @@
|
||||
This example is for use with [Arduino as a component](https://espressif-docs.readthedocs-hosted.com/projects/arduino-esp32/en/latest/esp-idf_component.html) in the ESP-IDF framework.
|
||||
|
||||
Be sure to follow [this section](https://espressif-docs.readthedocs-hosted.com/projects/arduino-esp32/en/latest/esp-idf_component.html#adding-local-library) about adding libraries to your project.
|
||||
@@ -1,3 +0,0 @@
|
||||
idf_component_register(
|
||||
SRCS "main.cpp"
|
||||
INCLUDE_DIRS "")
|
||||
@@ -1,142 +0,0 @@
|
||||
#include <Arduino.h>
|
||||
#include <WiFi.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void WiFiEvent(WiFiEvent_t event) {
|
||||
Serial.printf("[WiFi-event] event: %d\n", event);
|
||||
switch(event) {
|
||||
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
|
||||
Serial.println("WiFi connected");
|
||||
Serial.println("IP address: ");
|
||||
Serial.println(WiFi.localIP());
|
||||
connectToMqtt();
|
||||
break;
|
||||
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
|
||||
Serial.println("WiFi lost connection");
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.persistent(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
#
|
||||
# Bootloader config
|
||||
#
|
||||
CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
|
||||
CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y
|
||||
CONFIG_BOOTLOADER_LOG_LEVEL=0
|
||||
|
||||
#
|
||||
# Serial flasher config
|
||||
#
|
||||
CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
|
||||
CONFIG_ESPTOOLPY_FLASHMODE="dio"
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ_40M=y
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ="40m"
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE="4MB"
|
||||
#
|
||||
# Partition Table
|
||||
#
|
||||
CONFIG_PARTITION_TABLE_CUSTOM=n
|
||||
|
||||
#
|
||||
# Arduino Configuration
|
||||
#
|
||||
CONFIG_ARDUINO_VARIANT="esp32"
|
||||
CONFIG_ENABLE_ARDUINO_DEPENDS=y
|
||||
CONFIG_AUTOSTART_ARDUINO=y
|
||||
|
||||
#
|
||||
# FreeRTOS
|
||||
#
|
||||
# 1000 require for Arduino
|
||||
CONFIG_FREERTOS_HZ=1000
|
||||
|
||||
#ASYNC_TCP
|
||||
CONFIG_ASYNC_TCP_RUN_NO_AFFINITY=y
|
||||
|
||||
#MBEDTLS
|
||||
CONFIG_MBEDTLS_PSK_MODES=y
|
||||
@@ -1,141 +0,0 @@
|
||||
#include <WiFi.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void WiFiEvent(WiFiEvent_t event) {
|
||||
Serial.printf("[WiFi-event] event: %d\n", event);
|
||||
switch(event) {
|
||||
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
|
||||
Serial.println("WiFi connected");
|
||||
Serial.println("IP address: ");
|
||||
Serial.println(WiFi.localIP());
|
||||
connectToMqtt();
|
||||
break;
|
||||
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
|
||||
Serial.println("WiFi lost connection");
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.persistent(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,139 +0,0 @@
|
||||
#include <ESP8266WiFi.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
|
||||
(void) event;
|
||||
Serial.println("Connected to Wi-Fi.");
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
|
||||
(void) event;
|
||||
Serial.println("Disconnected from Wi-Fi.");
|
||||
}
|
||||
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.setAutoConnect(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
mqttClient.loop();
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
#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;
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
; 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
|
||||
-Werror
|
||||
|
||||
[env:native]
|
||||
platform = native
|
||||
build_flags =
|
||||
${common.build_flags}
|
||||
-D EMC_RX_BUFFER_SIZE=1500
|
||||
build_type = debug
|
||||
lib_compat_mode = off
|
||||
@@ -1,141 +0,0 @@
|
||||
#include <WiFi.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void WiFiEvent(WiFiEvent_t event) {
|
||||
Serial.printf("[WiFi-event] event: %d\n", event);
|
||||
switch(event) {
|
||||
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
|
||||
Serial.println("WiFi connected");
|
||||
Serial.println("IP address: ");
|
||||
Serial.println(WiFi.localIP());
|
||||
connectToMqtt();
|
||||
break;
|
||||
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
|
||||
Serial.println("WiFi lost connection");
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.persistent(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,138 +0,0 @@
|
||||
#include <ESP8266WiFi.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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
|
||||
(void) event;
|
||||
Serial.println("Connected to Wi-Fi.");
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
|
||||
(void) event;
|
||||
Serial.println("Disconnected from Wi-Fi.");
|
||||
}
|
||||
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.setAutoConnect(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,170 +0,0 @@
|
||||
#include <WiFi.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(espMqttClientTypes::UseInternalTask::NO);
|
||||
static TaskHandle_t taskHandle;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void WiFiEvent(WiFiEvent_t event) {
|
||||
Serial.printf("[WiFi-event] event: %d\n", event);
|
||||
switch(event) {
|
||||
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
|
||||
Serial.println("WiFi connected");
|
||||
Serial.println("IP address: ");
|
||||
Serial.println(WiFi.localIP());
|
||||
connectToMqtt();
|
||||
break;
|
||||
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
|
||||
Serial.println("WiFi lost connection");
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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 networkingTask() {
|
||||
for (;;) {
|
||||
mqttClient.loop();
|
||||
}
|
||||
}
|
||||
|
||||
void setup() {
|
||||
Serial.begin(115200);
|
||||
Serial.println();
|
||||
Serial.println();
|
||||
|
||||
WiFi.persistent(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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);
|
||||
|
||||
xTaskCreatePinnedToCore((TaskFunction_t)networkingTask, "mqttclienttask", 5120, nullptr, 1, &taskHandle, 0);
|
||||
|
||||
connectToWiFi();
|
||||
}
|
||||
|
||||
void loop() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
static uint32_t lastMillis = 0;
|
||||
if (currentMillis - lastMillis > 5000) {
|
||||
lastMillis = currentMillis;
|
||||
Serial.printf("heap: %u\n", ESP.getFreeHeap());
|
||||
}
|
||||
|
||||
static uint32_t millisDisconnect = 0;
|
||||
if (currentMillis - millisDisconnect > 60000) {
|
||||
millisDisconnect = currentMillis;
|
||||
mqttClient.disconnect();
|
||||
}
|
||||
}
|
||||
@@ -1,144 +0,0 @@
|
||||
#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;
|
||||
bool reconnectMqtt = false;
|
||||
uint32_t lastReconnect = 0;
|
||||
|
||||
void connectToWiFi() {
|
||||
Serial.println("Connecting to Wi-Fi...");
|
||||
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
||||
}
|
||||
|
||||
void connectToMqtt() {
|
||||
Serial.println("Connecting to MQTT...");
|
||||
if (!mqttClient.connect()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
Serial.println("Connecting failed.");
|
||||
} else {
|
||||
reconnectMqtt = false;
|
||||
}
|
||||
}
|
||||
|
||||
void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
|
||||
(void) event;
|
||||
Serial.println("Connected to Wi-Fi.");
|
||||
connectToMqtt();
|
||||
}
|
||||
|
||||
void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
|
||||
(void) event;
|
||||
Serial.println("Disconnected from Wi-Fi.");
|
||||
}
|
||||
|
||||
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()) {
|
||||
reconnectMqtt = true;
|
||||
lastReconnect = millis();
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
(void) payload;
|
||||
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.setAutoConnect(false);
|
||||
WiFi.setAutoReconnect(true);
|
||||
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() {
|
||||
static uint32_t currentMillis = millis();
|
||||
|
||||
mqttClient.loop();
|
||||
if (reconnectMqtt && currentMillis - lastReconnect > 5000) {
|
||||
connectToMqtt();
|
||||
}
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
# 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
|
||||
queueSize 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
|
||||
@@ -1,25 +0,0 @@
|
||||
{
|
||||
"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.7.0",
|
||||
"frameworks": "arduino",
|
||||
"platforms": ["espressif8266", "espressif32"],
|
||||
"headers": ["espMqttClient.h", "espMqttClientAsync.h"],
|
||||
"build":
|
||||
{
|
||||
"libLDFMode": "deep+"
|
||||
}
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
name=espMqttClient
|
||||
version=1.7.0
|
||||
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
|
||||
@@ -1,43 +0,0 @@
|
||||
; 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
|
||||
-ggdb3
|
||||
|
||||
[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
|
||||
-D EMC_MULTIPLE_CALLBACKS=1
|
||||
-D EMC_USE_MEMPOOL=1
|
||||
;extra_scripts = test-coverage.py
|
||||
build_type = debug
|
||||
test_testing_command =
|
||||
valgrind
|
||||
--leak-check=full
|
||||
--show-leak-kinds=all
|
||||
--track-origins=yes
|
||||
--error-exitcode=1
|
||||
${platformio.build_dir}/${this.__env__}/program
|
||||
@@ -1,30 +0,0 @@
|
||||
#!/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)]) + "});")
|
||||
@@ -1,75 +0,0 @@
|
||||
/*
|
||||
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 10000
|
||||
#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 16384
|
||||
#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_WAIT_FOR_CONNACK
|
||||
#define EMC_WAIT_FOR_CONNACK 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 5120
|
||||
#endif
|
||||
|
||||
#ifndef EMC_MULTIPLE_CALLBACKS
|
||||
#define EMC_MULTIPLE_CALLBACKS 0
|
||||
#endif
|
||||
|
||||
#ifndef EMC_USE_WATCHDOG
|
||||
#define EMC_USE_WATCHDOG 0
|
||||
#endif
|
||||
|
||||
#ifndef EMC_USE_MEMPOOL
|
||||
#define EMC_USE_MEMPOOL 0
|
||||
#endif
|
||||
|
||||
#if EMC_USE_MEMPOOL
|
||||
#ifndef EMC_NUM_POOL_ELEMENTS
|
||||
#define EMC_NUM_POOL_ELEMENTS 32
|
||||
#endif
|
||||
#ifndef EMC_SIZE_POOL_ELEMENTS
|
||||
#define EMC_SIZE_POOL_ELEMENTS 128
|
||||
#endif
|
||||
#endif
|
||||
@@ -1,49 +0,0 @@
|
||||
/*
|
||||
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() vTaskDelay(1)
|
||||
#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
|
||||
@@ -1,43 +0,0 @@
|
||||
/*
|
||||
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 <esp32-hal-log.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#if defined(DEBUG_ESP_MQTT_CLIENT)
|
||||
// Logging is en/disabled by Arduino framework macros
|
||||
#define emc_log_i(...) log_i(__VA_ARGS__)
|
||||
#define emc_log_e(...) log_e(__VA_ARGS__)
|
||||
#define emc_log_w(...) log_w(__VA_ARGS__)
|
||||
#else
|
||||
// Logging is disabled
|
||||
#define emc_log_i(...)
|
||||
#define emc_log_e(...)
|
||||
#define emc_log_w(...)
|
||||
#endif
|
||||
#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
|
||||
@@ -1,21 +0,0 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2024 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.
|
||||
@@ -1,105 +0,0 @@
|
||||
# Memory Pool
|
||||
|
||||
EARLY VERSION. USE AT OWN RISK.
|
||||
|
||||
### Description
|
||||
|
||||
This is a simple memory pool that doesn't solve the fragmentation problem but contains it. Inside the pool you will still suffer memory fragmentation. The upside is that you're not restricted on memory size. As long as it fits in the pool, you can request any size!
|
||||
|
||||
For applications where the (maximum) size to allocate is known, a simple fixed block size memory pool is available. There is no memory fragmentation happening in this case. The downside is wastage of memory if you need less then the specified blocksize.
|
||||
|
||||
#### Features
|
||||
|
||||
- pool memory is statically allocated
|
||||
- pool size adjusts on architecture
|
||||
- no size calculation required: input number of blocks and size of block
|
||||
- header-only library
|
||||
- Variable size pool: no restriction on allocated size
|
||||
- Variable size pool: malloc and free are O(n); The number of allocated blocks affects lookup.
|
||||
- Fixed size pool: malloc and free are O(1).
|
||||
|
||||
[](https://github.com/bertmelis/MemoryPool/actions/workflows/test-platformio.yml)
|
||||
[](https://github.com/bertmelis/MemoryPool/actions/workflows/cpplint.yml)
|
||||
<!---[](https://github.com/bertmelis/MemoryPool/actions/workflows/cppcheck.yml)--->
|
||||
|
||||
### Usage
|
||||
|
||||
#### Variable size pool
|
||||
|
||||
```cpp
|
||||
#include <MemoryPool.h>
|
||||
|
||||
Struct MyStruct {
|
||||
unsigned int id;
|
||||
std::size_t size;
|
||||
unsigned char data[256];
|
||||
};
|
||||
|
||||
// pool will be able to hold 10 blocks the size of MyStruct
|
||||
MemoryPool::Variable<10, sizeof(MyStruct)> pool;
|
||||
|
||||
// you can allocate the specified blocksize
|
||||
// allocation is done in number of 'unsigned char'
|
||||
MyStruct* s = reinterpret_cast<MyStruct*>(pool.malloc(sizeof(MyStruct)));
|
||||
|
||||
// you can allocate less than the specified blocksize
|
||||
int* i = reinterpret_cast<int*>(pool.malloc(sizeof(int)));
|
||||
|
||||
// you can allocate more than the specified blocksize
|
||||
unsigned char* m = reinterpret_cast<unsigned char*>(pool.malloc(400));
|
||||
|
||||
pool.free(s);
|
||||
pool.free(i);
|
||||
pool.free(m);
|
||||
```
|
||||
|
||||
#### Fixed size pool
|
||||
|
||||
```cpp
|
||||
#include <MemoryPool.h>
|
||||
|
||||
Struct MyStruct {
|
||||
unsigned int id;
|
||||
std::size_t size;
|
||||
unsigned char data[256];
|
||||
};
|
||||
|
||||
// pool will be able to hold 10 blocks the size of MyStruct
|
||||
MemoryPool::Fixed<10, sizeof(MyStruct)> pool;
|
||||
|
||||
// there is no size argument in the malloc function!
|
||||
MyStruct* s = reinterpret_cast<MyStruct*>(pool.malloc());
|
||||
|
||||
// you can allocate less than the specified blocksize
|
||||
int* i = reinterpret_cast<int*>(pool.malloc());
|
||||
|
||||
pool.free(s);
|
||||
pool.free(i);
|
||||
```
|
||||
|
||||
#### How it works
|
||||
|
||||
##### Variable size pool
|
||||
|
||||
Free blocks are organized as a linked list with their header (contains pointer to next and size). An allocated block also has this header with it's pointer set to `nullptr`. Therefore, each allocation wastes memory the size of the header (`sizeof(void*) + sizeof(std::size_t)`). On creation, the pool calculations the needed space to store the number of blocks wich each their header.
|
||||
|
||||
However, memory allocation isn't restricted the the specified blocksize. So in reality, you can allocate more if you allocate larger chunks because less memory blocks means less headers. After all, memory needs to be contiguous.
|
||||
|
||||
If you inspect the pool you'll see that a free pool only has one big block.
|
||||
|
||||
Allocation is linear: the pool is iterated until a suitable spot is found.
|
||||
Freeing is also linear as the pool is traversed to insert the chunk in the linked list of free blocks
|
||||
|
||||
When freeing, free blocks which are adjacent are combined into one.
|
||||
|
||||
##### Fixed size pool
|
||||
|
||||
The fixed size pool is implemented as an array. Free blocks are saved as a linked list in this array.
|
||||
|
||||
### Bugs and feature requests
|
||||
|
||||
Please use Github's facilities to get in touch.
|
||||
|
||||
### License
|
||||
|
||||
This library is released under the MIT Licence. A copy is included in the repo.
|
||||
@@ -1,16 +0,0 @@
|
||||
# Datatypes (KEYWORD1)
|
||||
Fixed KEYWORD1
|
||||
Variable KEYWORD1
|
||||
|
||||
# Methods and Functions (KEYWORD2)
|
||||
malloc KEYWORD2
|
||||
free KEYWORD2
|
||||
freeMemory KEYWORD2
|
||||
maxBlockSize KEYWORD2
|
||||
print KEYWORD2
|
||||
|
||||
# Structures (KEYWORD3)
|
||||
# structure KEYWORD3
|
||||
|
||||
# Constants (LITERAL1)
|
||||
MemoryPool LITERAL1
|
||||
@@ -1,21 +0,0 @@
|
||||
{
|
||||
"name": "MemoryPool",
|
||||
"keywords": "memory",
|
||||
"description": "A simple memory pool for fixed and variable sizes",
|
||||
"authors":
|
||||
{
|
||||
"name": "Bert Melis",
|
||||
"url": "https://github.com/bertmelis"
|
||||
},
|
||||
"license": "MIT",
|
||||
"homepage": "https://github.com/bertmelis/MemoryPool",
|
||||
"repository":
|
||||
{
|
||||
"type": "git",
|
||||
"url": "https://github.com/bertmelis/MemoryPool.git"
|
||||
},
|
||||
"version": "0.1.0",
|
||||
"frameworks": "*",
|
||||
"platforms": "*",
|
||||
"headers": ["MemoryPool.h"]
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
name=MemoryPool
|
||||
version=0.1.0
|
||||
author=Bert Melis
|
||||
maintainer=Bert Melis
|
||||
sentence=A simple memory pool for fixed and variable sizes
|
||||
paragraph=
|
||||
category=Other
|
||||
url=https://github.com/bertmelis/MemoryPool
|
||||
architectures=*
|
||||
includes=MemoryPool.h
|
||||
@@ -1,119 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2024 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 <cstddef> // std::size_t
|
||||
#include <cassert> // assert
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
#include <mutex> // NOLINT [build/c++11] std::mutex, std::lock_guard
|
||||
#else
|
||||
#warning "The memory pool is not thread safe"
|
||||
#endif
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
#include <iostream>
|
||||
#endif
|
||||
|
||||
namespace MemoryPool {
|
||||
|
||||
template <std::size_t nrBlocks, std::size_t blocksize>
|
||||
class Fixed {
|
||||
public:
|
||||
Fixed() // cppcheck-suppress uninitMemberVar
|
||||
: _buffer{0}
|
||||
, _head(_buffer) {
|
||||
unsigned char* b = _head;
|
||||
std::size_t adjustedBlocksize = sizeof(std::size_t) > blocksize ? sizeof(std::size_t) : blocksize;
|
||||
for (std::size_t i = 0; i < nrBlocks - 1; ++i) {
|
||||
*reinterpret_cast<unsigned char**>(b) = b + adjustedBlocksize;
|
||||
b += adjustedBlocksize;
|
||||
}
|
||||
*reinterpret_cast<unsigned char**>(b) = nullptr;
|
||||
}
|
||||
|
||||
// no copy nor move
|
||||
Fixed (const Fixed&) = delete;
|
||||
Fixed& operator= (const Fixed&) = delete;
|
||||
|
||||
void* malloc() {
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
if (_head) {
|
||||
void* retVal = _head;
|
||||
_head = *reinterpret_cast<unsigned char**>(_head);
|
||||
return retVal;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void free(void* ptr) {
|
||||
if (!ptr) return;
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
*reinterpret_cast<unsigned char**>(ptr) = _head;
|
||||
_head = reinterpret_cast<unsigned char*>(ptr);
|
||||
}
|
||||
|
||||
std::size_t freeMemory() {
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
unsigned char* i = _head;
|
||||
std::size_t retVal = 0;
|
||||
while (i) {
|
||||
retVal += blocksize;
|
||||
i = reinterpret_cast<unsigned char**>(i)[0];
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
void print() {
|
||||
std::size_t adjustedBlocksize = sizeof(std::size_t) > blocksize ? sizeof(std::size_t) : blocksize;
|
||||
std::cout << "+--------------------" << std::endl;
|
||||
std::cout << "|start:" << reinterpret_cast<void*>(_buffer) << std::endl;
|
||||
std::cout << "|blocks:" << nrBlocks << std::endl;
|
||||
std::cout << "|blocksize:" << adjustedBlocksize << std::endl;
|
||||
std::cout << "|head: " << reinterpret_cast<void*>(_head) << std::endl;
|
||||
unsigned char* currentBlock = _buffer;
|
||||
|
||||
for (std::size_t i = 0; i < nrBlocks; ++i) {
|
||||
std::cout << "|" << i + 1 << ": " << reinterpret_cast<void*>(currentBlock) << std::endl;
|
||||
if (_isFree(currentBlock)) {
|
||||
std::cout << "| free" << std::endl;
|
||||
std::cout << "| next: " << reinterpret_cast<void*>(*reinterpret_cast<unsigned char**>(currentBlock)) << std::endl;
|
||||
} else {
|
||||
std::cout << "| allocated" << std::endl;
|
||||
}
|
||||
currentBlock += adjustedBlocksize;
|
||||
}
|
||||
std::cout << "+--------------------" << std::endl;
|
||||
}
|
||||
|
||||
bool _isFree(const unsigned char* ptr) {
|
||||
unsigned char* b = _head;
|
||||
while (b) {
|
||||
if (b == ptr) return true;
|
||||
b = *reinterpret_cast<unsigned char**>(b);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
unsigned char _buffer[nrBlocks * (sizeof(std::size_t) > blocksize ? sizeof(std::size_t) : blocksize)];
|
||||
unsigned char* _head;
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
std::mutex _mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // end namespace MemoryPool
|
||||
@@ -1,12 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2024 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 "Variable.h"
|
||||
#include "Fixed.h"
|
||||
@@ -1,242 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2024 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 <cstddef> // std::size_t
|
||||
#include <cassert> // assert
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
#include <mutex> // NOLINT [build/c++11] std::mutex, std::lock_guard
|
||||
#else
|
||||
#warning "The memory pool is not thread safe"
|
||||
#endif
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
#include <iostream>
|
||||
#endif
|
||||
|
||||
namespace MemoryPool {
|
||||
|
||||
template <std::size_t nrBlocks, std::size_t blocksize>
|
||||
class Variable {
|
||||
public:
|
||||
Variable()
|
||||
: _buffer{0}
|
||||
, _head(nullptr)
|
||||
#ifdef MEMPOL_DEBUG
|
||||
, _bufferSize(0)
|
||||
#endif
|
||||
{
|
||||
std::size_t _normBlocksize = blocksize / sizeof(BlockHeader) + ((blocksize % sizeof(BlockHeader)) ? 1 : 0);
|
||||
size_t nrBlocksToAlloc = nrBlocks * (_normBlocksize + 1);
|
||||
BlockHeader* h = reinterpret_cast<BlockHeader*>(_buffer);
|
||||
h->next = nullptr;
|
||||
h->size = nrBlocksToAlloc;
|
||||
_head = h;
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
_bufferSize = nrBlocksToAlloc;
|
||||
#endif
|
||||
}
|
||||
|
||||
// no copy nor move
|
||||
Variable (const Variable&) = delete;
|
||||
Variable& operator= (const Variable&) = delete;
|
||||
|
||||
void* malloc(size_t size) {
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
if (size == 0) return nullptr;
|
||||
|
||||
size = (size / sizeof(BlockHeader) + (size % sizeof(BlockHeader) != 0)) + 1; // count by BlockHeader size, add 1 for header
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
std::cout << "malloc (raw) " << size << std::endl;
|
||||
std::cout << "malloc (adj) " << size << " - ";
|
||||
#endif
|
||||
|
||||
BlockHeader* currentBlock = _head;
|
||||
BlockHeader* previousBlock = nullptr;
|
||||
void* retVal = nullptr;
|
||||
|
||||
// iterate through linked free blocks
|
||||
while (currentBlock) {
|
||||
// consume whole block is size equals required size
|
||||
if (currentBlock->size == size) {
|
||||
if (previousBlock) previousBlock->next = currentBlock->next;
|
||||
break;
|
||||
|
||||
// split block if size is larger and add second part to list of free blocks
|
||||
} else if (currentBlock->size > size) {
|
||||
BlockHeader* newBlock = currentBlock + size;
|
||||
if (previousBlock) previousBlock->next = newBlock;
|
||||
newBlock->next = currentBlock->next;
|
||||
newBlock->size = currentBlock->size - size;
|
||||
currentBlock->next = newBlock;
|
||||
break;
|
||||
}
|
||||
previousBlock = currentBlock;
|
||||
currentBlock = currentBlock->next;
|
||||
}
|
||||
|
||||
if (currentBlock) {
|
||||
if (currentBlock == _head) {
|
||||
_head = currentBlock->next;
|
||||
}
|
||||
currentBlock->size = size;
|
||||
currentBlock->next = nullptr; // used when freeing memory
|
||||
retVal = currentBlock + 1;
|
||||
#ifdef MEMPOL_DEBUG
|
||||
std::cout << "ok" << std::endl;
|
||||
#endif
|
||||
} else {
|
||||
#ifdef MEMPOL_DEBUG
|
||||
std::cout << "nok" << std::endl;
|
||||
#endif
|
||||
(void)0;
|
||||
}
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
void free(void* ptr) {
|
||||
if (!ptr) return;
|
||||
// check if ptr points to region in _buffer
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
std::cout << "free " << static_cast<void*>(reinterpret_cast<BlockHeader*>(ptr) - 1) << std::endl;
|
||||
#endif
|
||||
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
|
||||
BlockHeader* toFree = reinterpret_cast<BlockHeader*>(ptr) - 1;
|
||||
BlockHeader* previous = reinterpret_cast<BlockHeader*>(_buffer);
|
||||
BlockHeader* next = _head;
|
||||
|
||||
// toFree is the only free block
|
||||
if (!next) {
|
||||
_head = toFree;
|
||||
return;
|
||||
}
|
||||
|
||||
while (previous) {
|
||||
if (!next || toFree < next) {
|
||||
// 1. add block to linked list of free blocks
|
||||
if (toFree < _head) {
|
||||
toFree->next = _head;
|
||||
_head = toFree;
|
||||
} else {
|
||||
previous->next = toFree;
|
||||
toFree->next = next;
|
||||
}
|
||||
|
||||
// 2. merge with previous if adjacent
|
||||
if (toFree > _head && toFree == previous + previous->size) {
|
||||
previous->size += toFree->size;
|
||||
previous->next = toFree->next;
|
||||
toFree = previous; // used in next check
|
||||
}
|
||||
|
||||
// 3. merge with next if adjacent
|
||||
if (toFree + toFree->size == next) {
|
||||
toFree->size += next->size;
|
||||
toFree->next = next->next;
|
||||
}
|
||||
|
||||
// 4. done
|
||||
return;
|
||||
}
|
||||
previous = next;
|
||||
next = next->next;
|
||||
}
|
||||
}
|
||||
|
||||
std::size_t freeMemory() {
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
size_t retVal = 0;
|
||||
BlockHeader* currentBlock = reinterpret_cast<BlockHeader*>(_head);
|
||||
|
||||
while (currentBlock) {
|
||||
retVal += currentBlock->size - 1;
|
||||
currentBlock = currentBlock->next;
|
||||
}
|
||||
|
||||
return retVal * sizeof(BlockHeader);
|
||||
}
|
||||
|
||||
std::size_t maxBlockSize() {
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
const std::lock_guard<std::mutex> lockGuard(_mutex);
|
||||
#endif
|
||||
size_t retVal = 0;
|
||||
BlockHeader* currentBlock = reinterpret_cast<BlockHeader*>(_head);
|
||||
|
||||
while (currentBlock) {
|
||||
retVal = (currentBlock->size - 1 > retVal) ? currentBlock->size - 1 : retVal;
|
||||
currentBlock = currentBlock->next;
|
||||
}
|
||||
|
||||
return retVal * sizeof(BlockHeader);
|
||||
}
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
void print() {
|
||||
std::cout << "+--------------------" << std::endl;
|
||||
std::cout << "|start:" << static_cast<void*>(_buffer) << std::endl;
|
||||
std::cout << "|size:" << _bufferSize << std::endl;
|
||||
std::cout << "|headersize:" << sizeof(BlockHeader) << std::endl;
|
||||
std::cout << "|head: " << static_cast<void*>(_head) << std::endl;
|
||||
BlockHeader* nextFreeBlock = _head;
|
||||
BlockHeader* currentBlock = reinterpret_cast<BlockHeader*>(_buffer);
|
||||
size_t blockNumber = 1;
|
||||
while (currentBlock < reinterpret_cast<BlockHeader*>(_buffer) + _bufferSize) {
|
||||
std::cout << "|" << blockNumber << ": " << static_cast<void*>(currentBlock) << std::endl;
|
||||
std::cout << "| " << static_cast<void*>(currentBlock->next) << std::endl;
|
||||
std::cout << "| " << currentBlock->size << std::endl;
|
||||
if (currentBlock == nextFreeBlock) {
|
||||
std::cout << "| free" << std::endl;
|
||||
nextFreeBlock = nextFreeBlock->next;
|
||||
} else {
|
||||
std::cout << "| allocated" << std::endl;
|
||||
}
|
||||
++blockNumber;
|
||||
currentBlock += currentBlock->size;
|
||||
}
|
||||
std::cout << "+--------------------" << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
struct BlockHeader {
|
||||
BlockHeader* next;
|
||||
std::size_t size;
|
||||
};
|
||||
/*
|
||||
pool size is aligned to sizeof(BlockHeader).
|
||||
requested blocksize is therefore multiple of blockheader (rounded up)
|
||||
total size = nr requested blocks * multiplier * blockheadersize
|
||||
|
||||
see constructor for calculation
|
||||
*/
|
||||
unsigned char _buffer[(nrBlocks * ((blocksize / sizeof(BlockHeader) + ((blocksize % sizeof(BlockHeader)) ? 1 : 0)) + 1)) * sizeof(BlockHeader)];
|
||||
BlockHeader* _head;
|
||||
#if _GLIBCXX_HAS_GTHREADS
|
||||
std::mutex _mutex;
|
||||
#endif
|
||||
|
||||
#ifdef MEMPOL_DEBUG
|
||||
std::size_t _bufferSize;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // end namespace MemoryPool
|
||||
@@ -1,746 +0,0 @@
|
||||
/*
|
||||
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;
|
||||
|
||||
MqttClient::MqttClient(espMqttClientTypes::UseInternalTask useInternalTask, uint8_t priority, uint8_t core)
|
||||
: _useInternalTask(useInternalTask)
|
||||
, _transport(nullptr)
|
||||
, _onConnectCallback(nullptr)
|
||||
, _onDisconnectCallback(nullptr)
|
||||
, _onSubscribeCallback(nullptr)
|
||||
, _onUnsubscribeCallback(nullptr)
|
||||
, _onMessageCallback(nullptr)
|
||||
, _onPublishCallback(nullptr)
|
||||
, _onErrorCallback(nullptr)
|
||||
, _clientId(nullptr)
|
||||
, _ip()
|
||||
, _host(nullptr)
|
||||
, _port(1883)
|
||||
, _useIp(false)
|
||||
, _keepAlive(15000)
|
||||
, _cleanSession(true)
|
||||
, _username(nullptr)
|
||||
, _password(nullptr)
|
||||
, _willTopic(nullptr)
|
||||
, _willPayload(nullptr)
|
||||
, _willPayloadLength(0)
|
||||
, _willQos(0)
|
||||
, _willRetain(false)
|
||||
, _timeout(EMC_TX_TIMEOUT)
|
||||
, _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) && ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
|
||||
, _highWaterMark(4294967295)
|
||||
#endif
|
||||
{
|
||||
EMC_GENERATE_CLIENTID(_generatedClientId);
|
||||
#if defined(ARDUINO_ARCH_ESP32)
|
||||
_xSemaphore = xSemaphoreCreateMutex();
|
||||
EMC_SEMAPHORE_GIVE(); // release before first use
|
||||
if (_useInternalTask == espMqttClientTypes::UseInternalTask::YES) {
|
||||
xTaskCreatePinnedToCore((TaskFunction_t)_loop, "mqttclient", EMC_TASK_STACK_SIZE, this, priority, &_taskHandle, core);
|
||||
}
|
||||
#else
|
||||
(void) useInternalTask;
|
||||
(void) priority;
|
||||
(void) core;
|
||||
#endif
|
||||
_clientId = _generatedClientId;
|
||||
}
|
||||
|
||||
MqttClient::~MqttClient() {
|
||||
disconnect(true);
|
||||
_clearQueue(2);
|
||||
#if defined(ARDUINO_ARCH_ESP32)
|
||||
vSemaphoreDelete(_xSemaphore);
|
||||
if (_useInternalTask == espMqttClientTypes::UseInternalTask::YES) {
|
||||
#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 = false;
|
||||
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)) {
|
||||
result = true;
|
||||
_setState(State::connectingTcp1);
|
||||
#if defined(ARDUINO_ARCH_ESP32)
|
||||
if (_useInternalTask == espMqttClientTypes::UseInternalTask::YES) {
|
||||
vTaskResume(_taskHandle);
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
emc_log_e("Could not create CONNECT packet");
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onError(0, Error::OUT_OF_MEMORY);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool MqttClient::disconnect(bool force) {
|
||||
if (force && _state != State::disconnected && _state != State::disconnectingTcp1 && _state != State::disconnectingTcp2) {
|
||||
_setState(State::disconnectingTcp1);
|
||||
return true;
|
||||
}
|
||||
if (!force && _state == State::connected) {
|
||||
_setState(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) {
|
||||
#else
|
||||
if (_state > State::connected) {
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
uint16_t packetId = (qos > 0) ? _getNextPacketId() : 1;
|
||||
if (!_addPacket(packetId, topic, payload, length, qos, retain)) {
|
||||
emc_log_e("Could not create PUBLISH packet");
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onError(packetId, Error::OUT_OF_MEMORY);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
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) {
|
||||
#else
|
||||
if (_state > State::connected) {
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
uint16_t packetId = (qos > 0) ? _getNextPacketId() : 1;
|
||||
if (!_addPacket(packetId, topic, callback, length, qos, retain)) {
|
||||
emc_log_e("Could not create PUBLISH packet");
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onError(packetId, Error::OUT_OF_MEMORY);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
packetId = 0;
|
||||
}
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
return packetId;
|
||||
}
|
||||
|
||||
void MqttClient::clearQueue(bool deleteSessionData) {
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
_clearQueue(deleteSessionData ? 2 : 0);
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
}
|
||||
|
||||
const char* MqttClient::getClientId() const {
|
||||
return _clientId;
|
||||
}
|
||||
|
||||
size_t MqttClient::queueSize() {
|
||||
size_t ret = 0;
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
ret = _outbox.size();
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
return ret;
|
||||
}
|
||||
|
||||
void MqttClient::loop() {
|
||||
switch (_state) {
|
||||
case State::disconnected:
|
||||
#if defined(ARDUINO_ARCH_ESP32)
|
||||
if (_useInternalTask == espMqttClientTypes::UseInternalTask::YES) {
|
||||
vTaskSuspend(_taskHandle);
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
case State::connectingTcp1:
|
||||
if (_useIp ? _transport->connect(_ip, _port) : _transport->connect(_host, _port)) {
|
||||
_setState(State::connectingTcp2);
|
||||
} else {
|
||||
_setState(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();
|
||||
_setState(State::connectingMqtt);
|
||||
} else if (_transport->disconnected()) { // sync: implemented as "not connected"; async: depending on state of pcb in underlying lib
|
||||
_setState(State::disconnectingTcp1);
|
||||
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
|
||||
}
|
||||
break;
|
||||
case State::connectingMqtt:
|
||||
#if EMC_WAIT_FOR_CONNACK
|
||||
if (_transport->connected()) {
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
_sendPacket();
|
||||
_checkIncoming();
|
||||
_checkPing();
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
} else {
|
||||
_setState(State::disconnectingTcp1);
|
||||
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
|
||||
}
|
||||
break;
|
||||
#else
|
||||
// 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]];
|
||||
#endif
|
||||
case State::connected:
|
||||
[[fallthrough]];
|
||||
case State::disconnectingMqtt2:
|
||||
if (_transport->connected()) {
|
||||
// CONNECT packet is first in the queue
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
_checkOutbox();
|
||||
_checkIncoming();
|
||||
_checkPing();
|
||||
_checkTimeout();
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
} else {
|
||||
_setState(State::disconnectingTcp1);
|
||||
_disconnectReason = DisconnectReason::TCP_DISCONNECTED;
|
||||
}
|
||||
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);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
} else {
|
||||
_setState(State::disconnectingMqtt2);
|
||||
}
|
||||
}
|
||||
_checkOutbox();
|
||||
_checkIncoming();
|
||||
_checkPing();
|
||||
_checkTimeout();
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
break;
|
||||
case State::disconnectingTcp1:
|
||||
_transport->stop();
|
||||
_setState(State::disconnectingTcp2);
|
||||
break; // keep break to accomodate async clients
|
||||
case State::disconnectingTcp2:
|
||||
if (_transport->disconnected()) {
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
_clearQueue(0);
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_bytesSent = 0;
|
||||
_setState(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
|
||||
|
||||
inline void MqttClient::_setState(State newState) {
|
||||
emc_log_i("state %i --> %i", static_cast<std::underlying_type<State>::type>(_state.load()), static_cast<std::underlying_type<State>::type>(newState));
|
||||
_state = newState;
|
||||
}
|
||||
|
||||
uint16_t MqttClient::_getNextPacketId() {
|
||||
++_packetId;
|
||||
if (_packetId == 0) ++_packetId;
|
||||
return _packetId;
|
||||
}
|
||||
|
||||
void MqttClient::_checkOutbox() {
|
||||
while (_sendPacket() > 0) {
|
||||
if (!_advanceOutbox()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int MqttClient::_sendPacket() {
|
||||
OutgoingPacket* packet = _outbox.getCurrent();
|
||||
|
||||
size_t written = 0;
|
||||
if (packet) {
|
||||
size_t wantToWrite = packet->packet.available(_bytesSent);
|
||||
if (wantToWrite == 0) {
|
||||
return 0;
|
||||
}
|
||||
written = _transport->write(packet->packet.data(_bytesSent), wantToWrite);
|
||||
packet->timeSent = millis();
|
||||
_lastClientActivity = millis();
|
||||
_bytesSent += written;
|
||||
emc_log_i("tx %zu/%zu (%02x)", _bytesSent, packet->packet.size(), packet->packet.packetType());
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
bool MqttClient::_advanceOutbox() {
|
||||
OutgoingPacket* packet = _outbox.getCurrent();
|
||||
if (packet && _bytesSent == packet->packet.size()) {
|
||||
if ((packet->packet.packetType()) == PacketType.DISCONNECT) {
|
||||
_setState(State::disconnectingTcp1);
|
||||
_disconnectReason = DisconnectReason::USER_OK;
|
||||
}
|
||||
if (packet->packet.removable()) {
|
||||
_outbox.removeCurrent();
|
||||
} else {
|
||||
// we already set 'dup' here, in case we have to retry
|
||||
if ((packet->packet.packetType()) == PacketType.PUBLISH) packet->packet.setDup();
|
||||
_outbox.next();
|
||||
}
|
||||
packet = _outbox.getCurrent();
|
||||
_bytesSent = 0;
|
||||
}
|
||||
return packet;
|
||||
}
|
||||
|
||||
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");
|
||||
_setState(State::disconnectingTcp1);
|
||||
return;
|
||||
}
|
||||
switch (packetType) {
|
||||
case PacketType.CONNACK:
|
||||
_onConnack();
|
||||
if (_state != State::connected) {
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case PacketType.PUBLISH:
|
||||
if (_state >= State::disconnectingMqtt1) 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");
|
||||
_setState(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");
|
||||
_setState(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))) {
|
||||
if (!_addPacket(PacketType.PINGREQ)) {
|
||||
emc_log_e("Could not create PING packet");
|
||||
return;
|
||||
}
|
||||
_pingSent = true;
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_checkTimeout() {
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.front();
|
||||
// check that we're not busy sending
|
||||
// don't check when first item hasn't been sent yet
|
||||
if (it && _bytesSent == 0 && it.get() != _outbox.getCurrent()) {
|
||||
if (millis() - it.get()->timeSent > _timeout) {
|
||||
emc_log_w("Packet ack timeout, retrying");
|
||||
_outbox.resetCurrent();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onConnack() {
|
||||
if (_parser.getPacket().variableHeader.fixed.connackVarHeader.returnCode == 0x00) {
|
||||
_pingSent = false; // reset after keepalive timeout disconnect
|
||||
_setState(State::connected);
|
||||
_advanceOutbox();
|
||||
if (_parser.getPacket().variableHeader.fixed.connackVarHeader.sessionPresent == 0) {
|
||||
_clearQueue(1);
|
||||
}
|
||||
if (_onConnectCallback) {
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onConnectCallback(_parser.getPacket().variableHeader.fixed.connackVarHeader.sessionPresent);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
} else {
|
||||
_setState(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() {
|
||||
const 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) {
|
||||
if (!_addPacket(PacketType.PUBACK, packetId)) {
|
||||
emc_log_e("Could not create PUBACK packet");
|
||||
}
|
||||
}
|
||||
} else if (qos == 2) {
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.front();
|
||||
while (it) {
|
||||
if ((it.get()->packet.packetType()) == PacketType.PUBREC && it.get()->packet.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");
|
||||
}
|
||||
}
|
||||
}
|
||||
if (callback && _onMessageCallback) {
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onMessageCallback({qos, dup, retain, packetId},
|
||||
p.variableHeader.topic,
|
||||
p.payload.data,
|
||||
p.payload.length,
|
||||
p.payload.index,
|
||||
p.payload.total);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onPuback() {
|
||||
bool callback = false;
|
||||
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::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()->packet.packetType()) == PacketType.PUBLISH) {
|
||||
if (it.get()->packet.packetId() == idToMatch) {
|
||||
callback = true;
|
||||
_outbox.remove(it);
|
||||
break;
|
||||
}
|
||||
emc_log_w("Received out of order PUBACK");
|
||||
break;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if (callback) {
|
||||
if (_onPublishCallback) {
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onPublishCallback(idToMatch);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
} else {
|
||||
emc_log_w("No matching PUBLISH packet found");
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onPubrec() {
|
||||
bool success = false;
|
||||
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::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()->packet.packetType()) == PacketType.PUBLISH) {
|
||||
if (it.get()->packet.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");
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onPubrel() {
|
||||
bool success = false;
|
||||
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::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()->packet.packetType()) == PacketType.PUBREC) {
|
||||
if (it.get()->packet.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");
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onPubcomp() {
|
||||
bool callback = false;
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::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()->packet.packetType()) == PacketType.PUBREL) {
|
||||
if (it.get()->packet.packetId() == idToMatch) {
|
||||
callback = true;
|
||||
_outbox.remove(it);
|
||||
break;
|
||||
}
|
||||
emc_log_w("Received out of order PUBCOMP");
|
||||
break;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if (callback) {
|
||||
if (_onPublishCallback) {
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onPublishCallback(idToMatch);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
} else {
|
||||
emc_log_w("No matching PUBREL packet found");
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onSuback() {
|
||||
bool callback = false;
|
||||
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.front();
|
||||
while (it) {
|
||||
if (((it.get()->packet.packetType()) == PacketType.SUBSCRIBE) && it.get()->packet.packetId() == idToMatch) {
|
||||
callback = true;
|
||||
_outbox.remove(it);
|
||||
break;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if (callback) {
|
||||
if (_onSubscribeCallback) {
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onSubscribeCallback(idToMatch, reinterpret_cast<const espMqttClientTypes::SubscribeReturncode*>(_parser.getPacket().payload.data), _parser.getPacket().payload.total);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
} else {
|
||||
emc_log_w("received SUBACK without SUB");
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onUnsuback() {
|
||||
bool callback = false;
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.front();
|
||||
uint16_t idToMatch = _parser.getPacket().variableHeader.fixed.packetId;
|
||||
while (it) {
|
||||
if (it.get()->packet.packetId() == idToMatch) {
|
||||
callback = true;
|
||||
_outbox.remove(it);
|
||||
break;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if (callback) {
|
||||
if (_onUnsubscribeCallback) {
|
||||
EMC_SEMAPHORE_GIVE();
|
||||
_onUnsubscribeCallback(idToMatch);
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
}
|
||||
} else {
|
||||
emc_log_w("received UNSUBACK without UNSUB");
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_clearQueue(int clearData) {
|
||||
emc_log_i("clearing queue (clear session: %d)", clearData);
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.front();
|
||||
if (clearData == 0) {
|
||||
// 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()->packet.packetType();
|
||||
if (type == PacketType.PUBREC ||
|
||||
type == PacketType.PUBREL ||
|
||||
(type == PacketType.PUBLISH && it.get()->packet.packetId() != 0)) {
|
||||
++it;
|
||||
} else {
|
||||
_outbox.remove(it);
|
||||
}
|
||||
}
|
||||
} else if (clearData == 1) {
|
||||
// keep PUB
|
||||
while (it) {
|
||||
if (it.get()->packet.packetType() == PacketType.PUBLISH) {
|
||||
++it;
|
||||
} else {
|
||||
_outbox.remove(it);
|
||||
}
|
||||
}
|
||||
} else { // clearData == 2
|
||||
while (it) {
|
||||
_outbox.remove(it);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MqttClient::_onError(uint16_t packetId, espMqttClientTypes::Error error) {
|
||||
if (_onErrorCallback) {
|
||||
_onErrorCallback(packetId, error);
|
||||
}
|
||||
}
|
||||
@@ -1,201 +0,0 @@
|
||||
/*
|
||||
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 = 0;
|
||||
if (_state != State::connected) {
|
||||
return packetId;
|
||||
} else {
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
packetId = _getNextPacketId();
|
||||
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 = 0;
|
||||
if (_state != State::connected) {
|
||||
return packetId;
|
||||
} else {
|
||||
EMC_SEMAPHORE_TAKE();
|
||||
packetId = _getNextPacketId();
|
||||
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 deleteSessionData = false); // Not MQTT compliant and may cause unpredictable results when `deleteSessionData` = true!
|
||||
const char* getClientId() const;
|
||||
size_t queueSize(); // No const because of mutex
|
||||
void loop();
|
||||
|
||||
protected:
|
||||
explicit MqttClient(espMqttClientTypes::UseInternalTask useInternalTask, uint8_t priority = 1, uint8_t core = 1);
|
||||
espMqttClientTypes::UseInternalTask _useInternalTask;
|
||||
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;
|
||||
uint32_t _timeout;
|
||||
|
||||
// state is protected to allow state changes by the transport system, defined in child classes
|
||||
// eg. to allow AsyncTCP
|
||||
enum class State {
|
||||
disconnected = 0,
|
||||
connectingTcp1 = 1,
|
||||
connectingTcp2 = 2,
|
||||
connectingMqtt = 3,
|
||||
connected = 4,
|
||||
disconnectingMqtt1 = 5,
|
||||
disconnectingMqtt2 = 6,
|
||||
disconnectingTcp1 = 7,
|
||||
disconnectingTcp2 = 8
|
||||
};
|
||||
std::atomic<State> _state;
|
||||
inline void _setState(State newState);
|
||||
|
||||
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];
|
||||
struct OutgoingPacket {
|
||||
uint32_t timeSent;
|
||||
espMqttClientInternals::Packet packet;
|
||||
template <typename... Args>
|
||||
OutgoingPacket(uint32_t t, espMqttClientTypes::Error& error, Args&&... args) : // NOLINT(runtime/references)
|
||||
timeSent(t),
|
||||
packet(error, std::forward<Args>(args) ...) {}
|
||||
};
|
||||
espMqttClientInternals::Outbox<OutgoingPacket> _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(espMqttClientTypes::Error::SUCCESS);
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.emplace(0, error, std::forward<Args>(args) ...);
|
||||
if (it && error == espMqttClientTypes::Error::SUCCESS) {
|
||||
return true;
|
||||
} else {
|
||||
if (it) _outbox.remove(it);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename... Args>
|
||||
bool _addPacketFront(Args&&... args) {
|
||||
espMqttClientTypes::Error error(espMqttClientTypes::Error::SUCCESS);
|
||||
espMqttClientInternals::Outbox<OutgoingPacket>::Iterator it = _outbox.emplaceFront(0, error, std::forward<Args>(args) ...);
|
||||
if (it && error == espMqttClientTypes::Error::SUCCESS) {
|
||||
return true;
|
||||
} else {
|
||||
if (it) _outbox.remove(it);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void _checkOutbox();
|
||||
int _sendPacket();
|
||||
bool _advanceOutbox();
|
||||
void _checkIncoming();
|
||||
void _checkPing();
|
||||
void _checkTimeout();
|
||||
|
||||
void _onConnack();
|
||||
void _onPublish();
|
||||
void _onPuback();
|
||||
void _onPubrec();
|
||||
void _onPubrel();
|
||||
void _onPubcomp();
|
||||
void _onSuback();
|
||||
void _onUnsuback();
|
||||
|
||||
void _clearQueue(int clearData); // 0: keep session,
|
||||
// 1: keep only PUBLISH qos > 0
|
||||
// 2: delete all
|
||||
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
|
||||
};
|
||||
@@ -1,245 +0,0 @@
|
||||
/*
|
||||
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"
|
||||
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
#include <list>
|
||||
#include <utility>
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
class MqttClientSetup : public MqttClient {
|
||||
public:
|
||||
T& setKeepAlive(uint16_t keepAlive) {
|
||||
_keepAlive = keepAlive * 1000; // s to ms conversion, will also do 16 to 32 bit conversion
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& setClientId(const char* clientId) {
|
||||
_clientId = clientId;
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& setCleanSession(bool cleanSession) {
|
||||
_cleanSession = cleanSession;
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& setCredentials(const char* username, const char* password) {
|
||||
_username = username;
|
||||
_password = password;
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& 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;
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& 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));
|
||||
}
|
||||
|
||||
T& setServer(IPAddress ip, uint16_t port) {
|
||||
_ip = ip;
|
||||
_port = port;
|
||||
_useIp = true;
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& setServer(const char* host, uint16_t port) {
|
||||
_host = host;
|
||||
_port = port;
|
||||
_useIp = false;
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& setTimeout(uint16_t timeout) {
|
||||
_timeout = timeout * 1000; // s to ms conversion, will also do 16 to 32 bit conversion
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& onConnect(espMqttClientTypes::OnConnectCallback callback, uint32_t id = 0) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onConnectCallbacks.emplace_back(callback, id);
|
||||
#else
|
||||
(void) id;
|
||||
_onConnectCallback = callback;
|
||||
#endif
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& onDisconnect(espMqttClientTypes::OnDisconnectCallback callback, uint32_t id = 0) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onDisconnectCallbacks.emplace_back(callback, id);
|
||||
#else
|
||||
(void) id;
|
||||
_onDisconnectCallback = callback;
|
||||
#endif
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& onSubscribe(espMqttClientTypes::OnSubscribeCallback callback, uint32_t id = 0) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onSubscribeCallbacks.emplace_back(callback, id);
|
||||
#else
|
||||
(void) id;
|
||||
_onSubscribeCallback = callback;
|
||||
#endif
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback, uint32_t id = 0) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onUnsubscribeCallbacks.emplace_back(callback, id);
|
||||
#else
|
||||
(void) id;
|
||||
_onUnsubscribeCallback = callback;
|
||||
#endif
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& onMessage(espMqttClientTypes::OnMessageCallback callback, uint32_t id = 0) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onMessageCallbacks.emplace_back(callback, id);
|
||||
#else
|
||||
(void) id;
|
||||
_onMessageCallback = callback;
|
||||
#endif
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& onPublish(espMqttClientTypes::OnPublishCallback callback, uint32_t id = 0) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onPublishCallbacks.emplace_back(callback, id);
|
||||
#else
|
||||
(void) id;
|
||||
_onPublishCallback = callback;
|
||||
#endif
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
T& removeOnConnect(uint32_t id) {
|
||||
for (auto it = _onConnectCallbacks.begin(); it != _onConnectCallbacks.end(); ++it) {
|
||||
if (it->second == id) {
|
||||
_onConnectCallbacks.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& removeOnDisconnect(uint32_t id) {
|
||||
for (auto it = _onDisconnectCallbacks.begin(); it != _onDisconnectCallbacks.end(); ++it) {
|
||||
if (it->second == id) {
|
||||
_onDisconnectCallbacks.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& removeOnSubscribe(uint32_t id) {
|
||||
for (auto it = _onSubscribeCallbacks.begin(); it != _onSubscribeCallbacks.end(); ++it) {
|
||||
if (it->second == id) {
|
||||
_onSubscribeCallbacks.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& removeOnUnsubscribe(uint32_t id) {
|
||||
for (auto it = _onUnsubscribeCallbacks.begin(); it != _onUnsubscribeCallbacks.end(); ++it) {
|
||||
if (it->second == id) {
|
||||
_onUnsubscribeCallbacks.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& removeOnMessage(uint32_t id) {
|
||||
for (auto it = _onMessageCallbacks.begin(); it != _onMessageCallbacks.end(); ++it) {
|
||||
if (it->second == id) {
|
||||
_onMessageCallbacks.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
|
||||
T& removeOnPublish(uint32_t id) {
|
||||
for (auto it = _onPublishCallbacks.begin(); it != _onPublishCallbacks.end(); ++it) {
|
||||
if (it->second == id) {
|
||||
_onPublishCallbacks.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
T& onError(espMqttClientTypes::OnErrorCallback callback) {
|
||||
_onErrorCallback = callback;
|
||||
return static_cast<T&>(*this);
|
||||
}
|
||||
*/
|
||||
|
||||
protected:
|
||||
explicit MqttClientSetup(espMqttClientTypes::UseInternalTask useInternalTask, uint8_t priority = 1, uint8_t core = 1)
|
||||
: MqttClient(useInternalTask, priority, core) {
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
_onConnectCallback = [this](bool sessionPresent) {
|
||||
for (auto callback : _onConnectCallbacks) if (callback.first) callback.first(sessionPresent);
|
||||
};
|
||||
_onDisconnectCallback = [this](espMqttClientTypes::DisconnectReason reason) {
|
||||
for (auto callback : _onDisconnectCallbacks) if (callback.first) callback.first(reason);
|
||||
};
|
||||
_onSubscribeCallback = [this](uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* returncodes, size_t len) {
|
||||
for (auto callback : _onSubscribeCallbacks) if (callback.first) callback.first(packetId, returncodes, len);
|
||||
};
|
||||
_onUnsubscribeCallback = [this](int16_t packetId) {
|
||||
for (auto callback : _onUnsubscribeCallbacks) if (callback.first) callback.first(packetId);
|
||||
};
|
||||
_onMessageCallback = [this](const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
|
||||
for (auto callback : _onMessageCallbacks) if (callback.first) callback.first(properties, topic, payload, len, index, total);
|
||||
};
|
||||
_onPublishCallback = [this](uint16_t packetId) {
|
||||
for (auto callback : _onPublishCallbacks) if (callback.first) callback.first(packetId);
|
||||
};
|
||||
#else
|
||||
// empty
|
||||
#endif
|
||||
}
|
||||
|
||||
#if EMC_MULTIPLE_CALLBACKS
|
||||
std::list<std::pair<espMqttClientTypes::OnConnectCallback, uint32_t>> _onConnectCallbacks;
|
||||
std::list<std::pair<espMqttClientTypes::OnDisconnectCallback, uint32_t>> _onDisconnectCallbacks;
|
||||
std::list<std::pair<espMqttClientTypes::OnSubscribeCallback, uint32_t>> _onSubscribeCallbacks;
|
||||
std::list<std::pair<espMqttClientTypes::OnUnsubscribeCallback, uint32_t>> _onUnsubscribeCallbacks;
|
||||
std::list<std::pair<espMqttClientTypes::OnMessageCallback, uint32_t>> _onMessageCallbacks;
|
||||
std::list<std::pair<espMqttClientTypes::OnPublishCallback, uint32_t>> _onPublishCallbacks;
|
||||
#endif
|
||||
};
|
||||
@@ -1,255 +0,0 @@
|
||||
|
||||
/*
|
||||
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 EMC_USE_MEMPOOL
|
||||
#include "MemoryPool/src/MemoryPool.h"
|
||||
#include "Config.h"
|
||||
#else
|
||||
#include <new> // new (std::nothrow)
|
||||
#endif
|
||||
#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)
|
||||
#if EMC_USE_MEMPOOL
|
||||
, _memPool()
|
||||
#endif
|
||||
{}
|
||||
~Outbox() {
|
||||
while (_first) {
|
||||
Node* n = _first->next;
|
||||
#if EMC_USE_MEMPOOL
|
||||
_first->~Node();
|
||||
_memPool.free(_first);
|
||||
#else
|
||||
delete _first;
|
||||
#endif
|
||||
_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;
|
||||
#if EMC_USE_MEMPOOL
|
||||
void* buf = _memPool.malloc();
|
||||
Node* node = nullptr;
|
||||
if (buf) {
|
||||
node = new(buf) Node(std::forward<Args>(args) ...);
|
||||
}
|
||||
#else
|
||||
Node* node = new(std::nothrow) Node(std::forward<Args>(args) ...);
|
||||
#endif
|
||||
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;
|
||||
#if EMC_USE_MEMPOOL
|
||||
void* buf = _memPool.malloc();
|
||||
Node* node = nullptr;
|
||||
if (buf) {
|
||||
node = new(buf) Node(std::forward<Args>(args) ...);
|
||||
}
|
||||
#else
|
||||
Node* node = new(std::nothrow) Node(std::forward<Args>(args) ...);
|
||||
#endif
|
||||
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)
|
||||
if (!it) return;
|
||||
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;
|
||||
}
|
||||
|
||||
void resetCurrent() {
|
||||
_current = _first;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
size_t size() const {
|
||||
Node* n = _first;
|
||||
size_t count = 0;
|
||||
while (n) {
|
||||
n = n->next;
|
||||
++count;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
private:
|
||||
Node* _first;
|
||||
Node* _last;
|
||||
Node* _current;
|
||||
Node* _prev; // element just before _current
|
||||
#if EMC_USE_MEMPOOL
|
||||
MemoryPool::Fixed<EMC_NUM_POOL_ELEMENTS, sizeof(Node)> _memPool;
|
||||
#endif
|
||||
|
||||
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
|
||||
#if EMC_USE_MEMPOOL
|
||||
node->~Node();
|
||||
_memPool.free(node);
|
||||
#else
|
||||
delete node;
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
} // end namespace espMqttClientInternals
|
||||
@@ -1,77 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,454 +0,0 @@
|
||||
/*
|
||||
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 {
|
||||
|
||||
#if EMC_USE_MEMPOOL
|
||||
MemoryPool::Variable<EMC_NUM_POOL_ELEMENTS, EMC_SIZE_POOL_ELEMENTS> Packet::_memPool;
|
||||
#endif
|
||||
|
||||
Packet::~Packet() {
|
||||
#if EMC_USE_MEMPOOL
|
||||
_memPool.free(_data);
|
||||
#else
|
||||
free(_data);
|
||||
#endif
|
||||
}
|
||||
|
||||
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)
|
||||
: _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, false)) {
|
||||
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)
|
||||
: _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, true)) {
|
||||
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)
|
||||
: _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)), true)) {
|
||||
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)
|
||||
: _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)
|
||||
: _packetId(packetId)
|
||||
, _data(nullptr)
|
||||
, _size(0)
|
||||
, _payloadIndex(0)
|
||||
, _payloadStartIndex(0)
|
||||
, _payloadEndIndex(0)
|
||||
, _getPayload(nullptr) {
|
||||
if (!_allocate(2, true)) {
|
||||
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)
|
||||
: _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)
|
||||
: _packetId(0)
|
||||
, _data(nullptr)
|
||||
, _size(0)
|
||||
, _payloadIndex(0)
|
||||
, _payloadStartIndex(0)
|
||||
, _payloadEndIndex(0)
|
||||
, _getPayload(nullptr) {
|
||||
if (!_allocate(0, true)) {
|
||||
error = espMqttClientTypes::Error::OUT_OF_MEMORY;
|
||||
return;
|
||||
}
|
||||
_data[0] |= type;
|
||||
|
||||
error = espMqttClientTypes::Error::SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
bool Packet::_allocate(size_t remainingLength, bool check) {
|
||||
#if EMC_USE_MEMPOOL
|
||||
(void) check;
|
||||
#else
|
||||
if (check && EMC_GET_FREE_MEMORY() < EMC_MIN_FREE_MEMORY) {
|
||||
emc_log_w("Packet buffer not allocated: low memory");
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
_size = 1 + remainingLengthLength(remainingLength) + remainingLength;
|
||||
#if EMC_USE_MEMPOOL
|
||||
_data = reinterpret_cast<uint8_t*>(_memPool.malloc(_size));
|
||||
#else
|
||||
_data = reinterpret_cast<uint8_t*>(malloc(_size));
|
||||
#endif
|
||||
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, true)) {
|
||||
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, true)) {
|
||||
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
|
||||
@@ -1,163 +0,0 @@
|
||||
/*
|
||||
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 "StringUtil.h"
|
||||
|
||||
#if EMC_USE_MEMPOOL
|
||||
#include "MemoryPool/src/MemoryPool.h"
|
||||
#endif
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
: _packetId(packetId)
|
||||
, _data(nullptr)
|
||||
, _size(0)
|
||||
, _payloadIndex(0)
|
||||
, _payloadStartIndex(0)
|
||||
, _payloadEndIndex(0)
|
||||
, _getPayload(nullptr) {
|
||||
static_assert(sizeof...(Args) % 2 == 0, "Subscribe should be in topic/qos pairs");
|
||||
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)
|
||||
: _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, bool check);
|
||||
|
||||
// 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;
|
||||
|
||||
#if EMC_USE_MEMPOOL
|
||||
static MemoryPool::Variable<EMC_NUM_POOL_ELEMENTS, EMC_SIZE_POOL_ELEMENTS> _memPool;
|
||||
#endif
|
||||
};
|
||||
|
||||
} // end namespace espMqttClientInternals
|
||||
@@ -1,316 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,100 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,57 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,32 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,26 +0,0 @@
|
||||
/*
|
||||
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 "StringUtil.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
|
||||
@@ -1,22 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,58 +0,0 @@
|
||||
/*
|
||||
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::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
|
||||
@@ -1,44 +0,0 @@
|
||||
/*
|
||||
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 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
|
||||
@@ -1,130 +0,0 @@
|
||||
/*
|
||||
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: \"%s\" opening socket", errno, strerror(errno));
|
||||
}
|
||||
|
||||
int flag = 1;
|
||||
if (setsockopt(_sockfd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int)) < 0) {
|
||||
emc_log_e("Error %d: \"%s\" disabling nagle", errno, strerror(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, reinterpret_cast<sockaddr*>(&_host), sizeof(_host));
|
||||
|
||||
if (ret < 0) {
|
||||
emc_log_e("Error connecting: %d - (%d) %s", ret, errno, strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
emc_log_i("Socket connected");
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ClientPosix::connect(const char* hostname, uint16_t port) {
|
||||
IPAddress ipAddress = _hostToIP(hostname);
|
||||
if (ipAddress == IPAddress(0)) {
|
||||
emc_log_e("No such host '%s'", hostname);
|
||||
return false;
|
||||
}
|
||||
return connect(ipAddress, port);
|
||||
}
|
||||
|
||||
size_t ClientPosix::write(const uint8_t* buf, size_t size) {
|
||||
return ::send(_sockfd, buf, size, 0);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
IPAddress ClientPosix::_hostToIP(const char* hostname) {
|
||||
IPAddress returnIP(0);
|
||||
struct addrinfo hints, *servinfo, *p;
|
||||
struct sockaddr_in *h;
|
||||
int rv;
|
||||
|
||||
// Set up request addrinfo struct
|
||||
memset(&hints, 0, sizeof hints);
|
||||
hints.ai_family = AF_UNSPEC;
|
||||
hints.ai_socktype = SOCK_STREAM;
|
||||
|
||||
emc_log_i("Looking for '%s'", hostname);
|
||||
|
||||
// ask for host data
|
||||
if ((rv = getaddrinfo(hostname, NULL, &hints, &servinfo)) != 0) {
|
||||
emc_log_e("getaddrinfo: %s", gai_strerror(rv));
|
||||
return returnIP;
|
||||
}
|
||||
|
||||
// loop through all the results and connect to the first we can
|
||||
for (p = servinfo; p != NULL; p = p->ai_next) {
|
||||
h = (struct sockaddr_in *)p->ai_addr;
|
||||
returnIP = ::htonl(h->sin_addr.s_addr);
|
||||
if (returnIP != IPAddress(0)) break;
|
||||
}
|
||||
// Release allocated memory
|
||||
freeaddrinfo(servinfo);
|
||||
|
||||
if (returnIP != IPAddress(0)) {
|
||||
emc_log_i("Host '%s' = %u", hostname, (uint32_t)returnIP);
|
||||
} else {
|
||||
emc_log_e("No IP for '%s' found", hostname);
|
||||
}
|
||||
return returnIP;
|
||||
}
|
||||
|
||||
} // namespace espMqttClientInternals
|
||||
|
||||
#endif
|
||||
@@ -1,54 +0,0 @@
|
||||
/*
|
||||
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 <arpa/inet.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* hostname, uint16_t port) override;
|
||||
size_t write(const uint8_t* buf, size_t size) override;
|
||||
int read(uint8_t* buf, size_t size) override;
|
||||
void stop() override;
|
||||
bool connected() override;
|
||||
bool disconnected() override;
|
||||
|
||||
protected:
|
||||
int _sockfd;
|
||||
sockaddr_in _host;
|
||||
|
||||
IPAddress _hostToIP(const char* hostname);
|
||||
};
|
||||
|
||||
} // namespace espMqttClientInternals
|
||||
|
||||
#endif
|
||||
@@ -1,40 +0,0 @@
|
||||
/*
|
||||
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 "ClientPosixIPAddress.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;
|
||||
}
|
||||
|
||||
bool IPAddress::operator==(IPAddress other) {
|
||||
return _address == other._address;
|
||||
}
|
||||
|
||||
bool IPAddress::operator!=(IPAddress other) {
|
||||
return _address != other._address;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,30 +0,0 @@
|
||||
/*
|
||||
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);
|
||||
IPAddress(uint32_t address); // NOLINT(runtime/explicit)
|
||||
operator uint32_t();
|
||||
bool operator==(IPAddress other);
|
||||
bool operator!=(IPAddress other);
|
||||
|
||||
protected:
|
||||
uint32_t _address;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,71 +0,0 @@
|
||||
/*
|
||||
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::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
|
||||
@@ -1,34 +0,0 @@
|
||||
/*
|
||||
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 read(uint8_t* buf, size_t size) override;
|
||||
void stop() override;
|
||||
bool connected() override;
|
||||
bool disconnected() override;
|
||||
WiFiClientSecure client;
|
||||
};
|
||||
|
||||
} // namespace espMqttClientInternals
|
||||
|
||||
#endif
|
||||
@@ -1,71 +0,0 @@
|
||||
/*
|
||||
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()
|
||||
: client() {
|
||||
// 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::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
|
||||
@@ -1,34 +0,0 @@
|
||||
/*
|
||||
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();
|
||||
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 read(uint8_t* buf, size_t size) override;
|
||||
void stop() override;
|
||||
bool connected() override;
|
||||
bool disconnected() override;
|
||||
WiFiClient client;
|
||||
};
|
||||
|
||||
} // namespace espMqttClientInternals
|
||||
|
||||
#endif
|
||||
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
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 "ClientPosixIPAddress.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 read(uint8_t* buf, size_t size) = 0;
|
||||
virtual void stop() = 0;
|
||||
virtual bool connected() = 0;
|
||||
virtual bool disconnected() = 0;
|
||||
};
|
||||
|
||||
} // namespace espMqttClientInternals
|
||||
@@ -1,51 +0,0 @@
|
||||
/*
|
||||
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
|
||||
@@ -1,73 +0,0 @@
|
||||
/*
|
||||
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;
|
||||
|
||||
enum class UseInternalTask {
|
||||
NO = 0,
|
||||
YES = 1,
|
||||
};
|
||||
|
||||
} // end namespace espMqttClientTypes
|
||||
@@ -1,113 +0,0 @@
|
||||
/*
|
||||
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_ESP8266)
|
||||
espMqttClient::espMqttClient()
|
||||
: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
|
||||
espMqttClientSecure::espMqttClientSecure()
|
||||
: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
|
||||
espMqttClientSecure& espMqttClientSecure::setInsecure() {
|
||||
_client.client.setInsecure();
|
||||
return *this;
|
||||
}
|
||||
|
||||
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
|
||||
|
||||
#if defined(ARDUINO_ARCH_ESP32)
|
||||
espMqttClient::espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask)
|
||||
: MqttClientSetup(useInternalTask)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
|
||||
espMqttClient::espMqttClient(uint8_t priority, uint8_t core)
|
||||
: MqttClientSetup(espMqttClientTypes::UseInternalTask::YES, priority, core)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
|
||||
espMqttClientSecure::espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask)
|
||||
: MqttClientSetup(useInternalTask)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
|
||||
espMqttClientSecure::espMqttClientSecure(uint8_t priority, uint8_t core)
|
||||
: MqttClientSetup(espMqttClientTypes::UseInternalTask::YES, priority, core)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
|
||||
espMqttClientSecure& espMqttClientSecure::setInsecure() {
|
||||
_client.client.setInsecure();
|
||||
return *this;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(__linux__)
|
||||
espMqttClient::espMqttClient()
|
||||
: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
|
||||
, _client() {
|
||||
_transport = &_client;
|
||||
}
|
||||
#endif
|
||||
@@ -1,80 +0,0 @@
|
||||
/*
|
||||
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"
|
||||
|
||||
#if defined(ARDUINO_ARCH_ESP8266)
|
||||
class espMqttClient : public MqttClientSetup<espMqttClient> {
|
||||
public:
|
||||
espMqttClient();
|
||||
|
||||
protected:
|
||||
espMqttClientInternals::ClientSync _client;
|
||||
};
|
||||
|
||||
class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
|
||||
public:
|
||||
espMqttClientSecure();
|
||||
espMqttClientSecure& setInsecure();
|
||||
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);
|
||||
|
||||
protected:
|
||||
espMqttClientInternals::ClientSecureSync _client;
|
||||
};
|
||||
#endif
|
||||
|
||||
#if defined(ARDUINO_ARCH_ESP32)
|
||||
class espMqttClient : public MqttClientSetup<espMqttClient> {
|
||||
public:
|
||||
explicit espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask);
|
||||
explicit espMqttClient(uint8_t priority = 1, uint8_t core = 1);
|
||||
|
||||
protected:
|
||||
espMqttClientInternals::ClientSync _client;
|
||||
};
|
||||
|
||||
class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
|
||||
public:
|
||||
explicit espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask);
|
||||
explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1);
|
||||
espMqttClientSecure& setInsecure();
|
||||
espMqttClientSecure& setCACert(const char* rootCA);
|
||||
espMqttClientSecure& setCertificate(const char* clientCa);
|
||||
espMqttClientSecure& setPrivateKey(const char* privateKey);
|
||||
espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey);
|
||||
|
||||
protected:
|
||||
espMqttClientInternals::ClientSecureSync _client;
|
||||
};
|
||||
#endif
|
||||
|
||||
#if defined(__linux__)
|
||||
class espMqttClient : public MqttClientSetup<espMqttClient> {
|
||||
public:
|
||||
espMqttClient();
|
||||
|
||||
protected:
|
||||
espMqttClientInternals::ClientPosix _client;
|
||||
};
|
||||
#endif
|
||||
@@ -1,61 +0,0 @@
|
||||
/*
|
||||
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"
|
||||
|
||||
espMqttClientAsync::espMqttClientAsync()
|
||||
: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
|
||||
, _clientAsync() {
|
||||
_transport = &_clientAsync;
|
||||
_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
|
||||
@@ -1,36 +0,0 @@
|
||||
/*
|
||||
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<espMqttClientAsync> {
|
||||
public:
|
||||
espMqttClientAsync();
|
||||
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
|
||||
@@ -1,22 +0,0 @@
|
||||
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)
|
||||
@@ -1,405 +0,0 @@
|
||||
#include <unity.h>
|
||||
#include <thread>
|
||||
#include <iostream>
|
||||
#include <espMqttClient.h> // espMqttClient for Linux also defines millis()
|
||||
|
||||
void setUp() {}
|
||||
void tearDown() {}
|
||||
|
||||
espMqttClient mqttClient;
|
||||
uint32_t onConnectCbId = 1;
|
||||
uint32_t onDisconnectCbId = 2;
|
||||
uint32_t onSubscribeCbId = 3;
|
||||
uint32_t onUnsubscribeCbId = 4;
|
||||
uint32_t onMessageCbId = 5;
|
||||
uint32_t onPublishCbId = 6;
|
||||
std::atomic_bool exitProgram(false);
|
||||
std::thread t;
|
||||
|
||||
//const IPAddress broker(127,0,0,1);
|
||||
const char* broker = "mqtt";
|
||||
//const char* broker = "test.mosquitto.org";
|
||||
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;
|
||||
}, onConnectCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnConnect(onConnectCbId);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
- 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;
|
||||
}
|
||||
}, onSubscribeCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnSubscribe(onSubscribeCbId);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
- 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++;
|
||||
}, onPublishCbId);
|
||||
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++;
|
||||
}, onMessageCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnPublish(onPublishCbId);
|
||||
mqttClient.removeOnMessage(onMessageCbId);
|
||||
}
|
||||
|
||||
void test_publish_empty() {
|
||||
std::atomic<int> publishSendEmptyTest(0);
|
||||
mqttClient.onPublish([&](uint16_t packetId) mutable {
|
||||
(void) packetId;
|
||||
publishSendEmptyTest++;
|
||||
}, onPublishCbId);
|
||||
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++;
|
||||
}, onMessageCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnPublish(onPublishCbId);
|
||||
mqttClient.removeOnMessage(onMessageCbId);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
- 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++;
|
||||
}, onMessageCbId);
|
||||
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, "");
|
||||
}
|
||||
}, onSubscribeCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnMessage(onMessageCbId);
|
||||
mqttClient.removeOnSubscribe(onSubscribeCbId);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
- 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++;
|
||||
}, onMessageCbId);
|
||||
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, "");
|
||||
}
|
||||
}, onSubscribeCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnMessage(onMessageCbId);
|
||||
mqttClient.removeOnSubscribe(onSubscribeCbId);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
|
||||
- client unsibscribes from topic
|
||||
|
||||
*/
|
||||
|
||||
void test_unsubscribe() {
|
||||
std::atomic<bool> unsubscribeTest(false);
|
||||
mqttClient.onUnsubscribe([&](uint16_t packetId) mutable {
|
||||
(void) packetId;
|
||||
unsubscribeTest = true;
|
||||
}, onUnsubscribeCbId);
|
||||
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);
|
||||
|
||||
mqttClient.removeOnUnsubscribe(onUnsubscribeCbId);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
- 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;
|
||||
}, onDisconnectCbId);
|
||||
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());
|
||||
|
||||
mqttClient.removeOnDisconnect(onDisconnectCbId);
|
||||
}
|
||||
|
||||
void test_pub_before_connect() {
|
||||
std::atomic<bool> onConnectCalledTest(false);
|
||||
std::atomic<int> publishSendTest(0);
|
||||
bool sessionPresentTest = true;
|
||||
mqttClient.setServer(broker, broker_port)
|
||||
.setCleanSession(true)
|
||||
.setKeepAlive(5)
|
||||
.onConnect([&](bool sessionPresent) mutable {
|
||||
sessionPresentTest = sessionPresent;
|
||||
onConnectCalledTest = true;
|
||||
}, onConnectCbId)
|
||||
.onPublish([&](uint16_t packetId) mutable {
|
||||
(void) packetId;
|
||||
publishSendTest++;
|
||||
}, onPublishCbId);
|
||||
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");
|
||||
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);
|
||||
start = millis();
|
||||
while (millis() - start < 10000) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
mqttClient.removeOnConnect(onConnectCbId);
|
||||
mqttClient.removeOnPublish(onPublishCbId);
|
||||
}
|
||||
|
||||
void final_disconnect() {
|
||||
std::atomic<bool> onDisconnectCalled(false);
|
||||
mqttClient.onDisconnect([&](espMqttClientTypes::DisconnectReason reason) mutable {
|
||||
(void) reason;
|
||||
onDisconnectCalled = true;
|
||||
}, onDisconnectCbId);
|
||||
mqttClient.disconnect();
|
||||
uint32_t start = millis();
|
||||
while (millis() - start < 2000) {
|
||||
if (onDisconnectCalled) {
|
||||
break;
|
||||
}
|
||||
std::this_thread::yield();
|
||||
}
|
||||
if (mqttClient.connected()) {
|
||||
mqttClient.disconnect(true);
|
||||
}
|
||||
mqttClient.removeOnDisconnect(onDisconnectCbId);
|
||||
}
|
||||
|
||||
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);
|
||||
RUN_TEST(test_pub_before_connect);
|
||||
final_disconnect();
|
||||
exitProgram = true;
|
||||
t.join();
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -1,171 +0,0 @@
|
||||
#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(523);
|
||||
// 523, current points to 523
|
||||
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
|
||||
TEST_ASSERT_EQUAL_UINT32(523, *(outbox.getCurrent()));
|
||||
TEST_ASSERT_FALSE(outbox.empty());
|
||||
|
||||
outbox.next();
|
||||
// 523, current points to nullptr
|
||||
TEST_ASSERT_NULL(outbox.getCurrent());
|
||||
|
||||
outbox.emplace(286);
|
||||
// 523 286, current points to 286
|
||||
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
|
||||
TEST_ASSERT_EQUAL_UINT32(286, *(outbox.getCurrent()));
|
||||
|
||||
outbox.emplace(364);
|
||||
// 523 286 364, current points to 286
|
||||
TEST_ASSERT_NOT_NULL(outbox.getCurrent());
|
||||
TEST_ASSERT_EQUAL_UINT32(286, *(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();
|
||||
}
|
||||
@@ -1,714 +0,0 @@
|
||||
#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();
|
||||
}
|
||||
@@ -1,355 +0,0 @@
|
||||
#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();
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
#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();
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
#include <iostream>
|
||||
|
||||
#include <unity.h>
|
||||
|
||||
#include <Packets/StringUtil.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();
|
||||
}
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
#define NUKI_HUB_VERSION "9.01"
|
||||
#define NUKI_HUB_BUILD "unknownbuildnr"
|
||||
#define NUKI_HUB_DATE "2024-08-28"
|
||||
#define NUKI_HUB_DATE "2024-08-31"
|
||||
|
||||
#define GITHUB_LATEST_RELEASE_URL (char*)"https://github.com/technyon/nuki_hub/releases/latest"
|
||||
#define GITHUB_OTA_MANIFEST_URL (char*)"https://raw.githubusercontent.com/technyon/nuki_hub/binary/ota/manifest.json"
|
||||
|
||||
@@ -123,18 +123,6 @@ void NukiNetwork::setupDevice()
|
||||
|
||||
Log->print(F("Network device: "));
|
||||
Log->print(_device->deviceName());
|
||||
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
_device->mqttOnConnect([&](bool sessionPresent)
|
||||
{
|
||||
onMqttConnect(sessionPresent);
|
||||
});
|
||||
_device->mqttOnDisconnect([&](espMqttClientTypes::DisconnectReason reason)
|
||||
{
|
||||
onMqttDisconnect(reason);
|
||||
});
|
||||
#endif
|
||||
}
|
||||
|
||||
void NukiNetwork::reconfigureDevice()
|
||||
@@ -242,55 +230,128 @@ void NukiNetwork::initialize()
|
||||
}
|
||||
}
|
||||
|
||||
Log->print(F("MQTT Broker: "));
|
||||
Log->print(_mqttBrokerAddr);
|
||||
Log->print(F(":"));
|
||||
Log->println(_mqttPort);
|
||||
|
||||
_device->mqttSetClientId(_hostnameArr);
|
||||
_device->mqttSetCleanSession(MQTT_CLEAN_SESSIONS);
|
||||
_device->mqttSetKeepAlive(MQTT_KEEP_ALIVE);
|
||||
|
||||
char gpioPath[250];
|
||||
bool rebGpio = rebuildGpio();
|
||||
|
||||
if(rebGpio)
|
||||
if(strcmp(_mqttBrokerAddr, "") == 0)
|
||||
{
|
||||
Log->println(F("Rebuild MQTT GPIO structure"));
|
||||
Log->println(F("MQTT Broker not configured, aborting connection attempt."));
|
||||
}
|
||||
for (const auto &pinEntry: _gpio->pinConfiguration())
|
||||
else
|
||||
{
|
||||
switch (pinEntry.role)
|
||||
Log->print(F("MQTT Broker: "));
|
||||
Log->print(_mqttBrokerAddr);
|
||||
Log->print(F(":"));
|
||||
Log->println(_mqttPort);
|
||||
|
||||
esp_mqtt_client_config_t mqtt_cfg = { 0 };
|
||||
|
||||
mqtt_cfg.credentials.client_id = _hostnameArr;
|
||||
mqtt_cfg.session.disable_clean_session = !MQTT_CLEAN_SESSIONS;
|
||||
mqtt_cfg.session.keepalive = MQTT_KEEP_ALIVE;
|
||||
|
||||
size_t caLength = _preferences->getString(preference_mqtt_ca, _ca, TLS_CA_MAX_SIZE);
|
||||
size_t crtLength = _preferences->getString(preference_mqtt_crt, _cert, TLS_CERT_MAX_SIZE);
|
||||
size_t keyLength = _preferences->getString(preference_mqtt_key, _key, TLS_KEY_MAX_SIZE);
|
||||
|
||||
if(caLength > 1)
|
||||
{
|
||||
case PinRole::GeneralInputPullDown:
|
||||
case PinRole::GeneralInputPullUp:
|
||||
if(rebGpio)
|
||||
{
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_role});
|
||||
publishString(_lockPath.c_str(), gpioPath, "input", false);
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_state});
|
||||
publishString(_lockPath.c_str(), gpioPath, std::to_string(digitalRead(pinEntry.pin)).c_str(), false);
|
||||
}
|
||||
break;
|
||||
case PinRole::GeneralOutput:
|
||||
if(rebGpio)
|
||||
{
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_role});
|
||||
publishString(_lockPath.c_str(), gpioPath, "output", false);
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_state});
|
||||
publishString(_lockPath.c_str(), gpioPath, "0", false);
|
||||
}
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_state});
|
||||
subscribe(_lockPath.c_str(), gpioPath);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
Log->println(F("MQTT over TLS."));
|
||||
|
||||
mqtt_cfg.broker.address.uri = ((String)"mqtts://" + _preferences->getString(preference_mqtt_broker, "") + ":" + _preferences->getString(preference_mqtt_broker_port, "8883")).c_str();
|
||||
mqtt_cfg.broker.verification.certificate = _ca;
|
||||
|
||||
if(crtLength > 1 && keyLength > 1) // length is 1 when empty
|
||||
{
|
||||
Log->println(F("MQTT with client certificate."));
|
||||
mqtt_cfg.credentials.authentication.certificate = _cert;
|
||||
mqtt_cfg.credentials.authentication.key = _key;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("MQTT without TLS."));
|
||||
mqtt_cfg.broker.address.uri = ((String)"mqtt://" + _preferences->getString(preference_mqtt_broker, "") + ":" + _preferences->getString(preference_mqtt_broker_port, "1883")).c_str();
|
||||
}
|
||||
|
||||
if(strlen(_mqttUser) == 0)
|
||||
{
|
||||
Log->println(F("MQTT: Connecting without credentials"));
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->print(F("MQTT: Connecting with user: ")); Log->println(_mqttUser);
|
||||
mqtt_cfg.credentials.username = _mqttUser;
|
||||
mqtt_cfg.credentials.authentication.password = _mqttPass;
|
||||
}
|
||||
|
||||
mqtt_cfg.session.last_will.topic = _mqttConnectionStateTopic;
|
||||
mqtt_cfg.session.last_will.msg = _lastWillPayload;
|
||||
mqtt_cfg.session.last_will.msg_len = sizeof(_lastWillPayload);
|
||||
mqtt_cfg.session.last_will.qos = 1;
|
||||
mqtt_cfg.session.last_will.retain = true;
|
||||
|
||||
esp_mqtt_client_handle_t _mqttClient = esp_mqtt_client_init(&mqtt_cfg);
|
||||
esp_mqtt_client_register_event(_mqttClient, (esp_mqtt_event_id_t)ESP_EVENT_ANY_ID, mqtt_event_handler_cb, NULL);
|
||||
|
||||
Log->println(F("Attempting MQTT connection"));
|
||||
esp_mqtt_client_start(_mqttClient);
|
||||
|
||||
if(_preferences->getBool(preference_mqtt_log_enabled, false) || _preferences->getBool(preference_webserial_enabled, false))
|
||||
{
|
||||
MqttLoggerMode mode;
|
||||
|
||||
if(_preferences->getBool(preference_mqtt_log_enabled, false) && _preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::MqttAndSerialAndWeb;
|
||||
else if (_preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::SerialAndWeb;
|
||||
else mode = MqttLoggerMode::MqttAndSerial;
|
||||
|
||||
char* _path = new char[200];
|
||||
memset(_path, 0, sizeof(_path));
|
||||
|
||||
String pathStr = _preferences->getString(preference_mqtt_lock_path);
|
||||
pathStr.concat(mqtt_topic_log);
|
||||
strcpy(_path, pathStr.c_str());
|
||||
Log = new MqttLogger(_mqttClient, _path, mode);
|
||||
}
|
||||
|
||||
char gpioPath[250];
|
||||
bool rebGpio = rebuildGpio();
|
||||
|
||||
if(rebGpio)
|
||||
{
|
||||
Log->println(F("Rebuild MQTT GPIO structure"));
|
||||
}
|
||||
for (const auto &pinEntry: _gpio->pinConfiguration())
|
||||
{
|
||||
switch (pinEntry.role)
|
||||
{
|
||||
case PinRole::GeneralInputPullDown:
|
||||
case PinRole::GeneralInputPullUp:
|
||||
if(rebGpio)
|
||||
{
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_role});
|
||||
publishString(_lockPath.c_str(), gpioPath, "input", false);
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_state});
|
||||
publishString(_lockPath.c_str(), gpioPath, std::to_string(digitalRead(pinEntry.pin)).c_str(), false);
|
||||
}
|
||||
break;
|
||||
case PinRole::GeneralOutput:
|
||||
if(rebGpio)
|
||||
{
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_role});
|
||||
publishString(_lockPath.c_str(), gpioPath, "output", false);
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_state});
|
||||
publishString(_lockPath.c_str(), gpioPath, "0", false);
|
||||
}
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pinEntry.pin)).c_str(), mqtt_topic_gpio_state});
|
||||
subscribe(_lockPath.c_str(), gpioPath);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
_gpio->addCallback([this](const GpioAction& action, const int& pin)
|
||||
{
|
||||
gpioActionCallback(action, pin);
|
||||
});
|
||||
}
|
||||
_gpio->addCallback([this](const GpioAction& action, const int& pin)
|
||||
{
|
||||
gpioActionCallback(action, pin);
|
||||
});
|
||||
|
||||
_discoveryTopic = _preferences->getString(preference_mqtt_hass_discovery, "");
|
||||
_offEnabled = _preferences->getBool(preference_official_hybrid, false);
|
||||
@@ -334,11 +395,6 @@ bool NukiNetwork::update()
|
||||
{
|
||||
_mqttConnectCounter = 0;
|
||||
|
||||
if(_firstDisconnected) {
|
||||
_firstDisconnected = false;
|
||||
_device->mqttDisconnect(true);
|
||||
}
|
||||
|
||||
if(!_webEnabled) forceEnableWebServer = true;
|
||||
if(_restartOnDisconnect && (esp_timer_get_time() / 1000) > 60000) restartEsp(RestartReason::RestartOnDisconnectWatchdog);
|
||||
|
||||
@@ -369,18 +425,17 @@ bool NukiNetwork::update()
|
||||
_logIp = false;
|
||||
Log->print(F("IP: "));
|
||||
Log->println(_device->localIP());
|
||||
_firstDisconnected = true;
|
||||
}
|
||||
|
||||
if(!_device->mqttConnected() && _device->isConnected())
|
||||
while(!_mqttConnected && _device->isConnected())
|
||||
{
|
||||
delay(2000);
|
||||
_mqttConnectCounter++;
|
||||
return false;
|
||||
}
|
||||
|
||||
if(!_mqttConnected && _device->isConnected())
|
||||
{
|
||||
bool success = reconnect();
|
||||
if(!success)
|
||||
{
|
||||
delay(2000);
|
||||
_mqttConnectCounter++;
|
||||
return false;
|
||||
}
|
||||
_mqttConnectCounter = 0;
|
||||
if(forceEnableWebServer && !_webEnabled)
|
||||
{
|
||||
@@ -392,7 +447,7 @@ bool NukiNetwork::update()
|
||||
delay(2000);
|
||||
}
|
||||
|
||||
if(!_device->mqttConnected() || !_device->isConnected())
|
||||
if(!_mqttConnected || !_device->isConnected())
|
||||
{
|
||||
if(_networkTimeout > 0 && (ts - _lastConnectedTs > _networkTimeout * 1000) && ts > 60000)
|
||||
{
|
||||
@@ -508,131 +563,91 @@ bool NukiNetwork::update()
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void NukiNetwork::onMqttConnect(const bool &sessionPresent)
|
||||
void NukiNetwork::mqtt_event_handler_cb(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
|
||||
{
|
||||
_connectReplyReceived = true;
|
||||
_inst->mqtt_event_handler(handler_args, base, event_id, event_data);
|
||||
}
|
||||
|
||||
void NukiNetwork::onMqttDisconnect(const espMqttClientTypes::DisconnectReason &reason)
|
||||
void NukiNetwork::mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
|
||||
{
|
||||
_connectReplyReceived = false;
|
||||
static const char *MQTT_TAG = "mqtt";
|
||||
|
||||
Log->print("MQTT disconnected. Reason: ");
|
||||
switch(reason)
|
||||
{
|
||||
case espMqttClientTypes::DisconnectReason::USER_OK:
|
||||
Log->println(F("USER_OK"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_UNACCEPTABLE_PROTOCOL_VERSION:
|
||||
Log->println(F("MQTT_UNACCEPTABLE_PROTOCOL_VERSION"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_IDENTIFIER_REJECTED:
|
||||
Log->println(F("MQTT_IDENTIFIER_REJECTED"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_SERVER_UNAVAILABLE:
|
||||
Log->println(F("MQTT_SERVER_UNAVAILABLE"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_MALFORMED_CREDENTIALS:
|
||||
Log->println(F("MQTT_MALFORMED_CREDENTIALS"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_NOT_AUTHORIZED:
|
||||
Log->println(F("MQTT_NOT_AUTHORIZED"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::TLS_BAD_FINGERPRINT:
|
||||
Log->println(F("TLS_BAD_FINGERPRINT"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::TCP_DISCONNECTED:
|
||||
Log->println(F("TCP_DISCONNECTED"));
|
||||
break;
|
||||
default:
|
||||
Log->println(F("Unknown"));
|
||||
break;
|
||||
ESP_LOGD(MQTT_TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id);
|
||||
esp_mqtt_event_handle_t event = (esp_mqtt_event_t*)event_data;
|
||||
esp_mqtt_client_handle_t client = event->client;
|
||||
int msg_id;
|
||||
switch ((esp_mqtt_event_id_t)event_id) {
|
||||
case MQTT_EVENT_CONNECTED:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_CONNECTED");
|
||||
_mqttConnected = true;
|
||||
reconnect();
|
||||
break;
|
||||
case MQTT_EVENT_DISCONNECTED:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_DISCONNECTED");
|
||||
_mqttConnected = false;
|
||||
break;
|
||||
case MQTT_EVENT_SUBSCRIBED:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
|
||||
break;
|
||||
case MQTT_EVENT_UNSUBSCRIBED:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
|
||||
break;
|
||||
case MQTT_EVENT_PUBLISHED:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
|
||||
break;
|
||||
case MQTT_EVENT_DATA:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_DATA");
|
||||
printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
|
||||
printf("DATA=%.*s\r\n", event->data_len, event->data);
|
||||
onMqttDataReceived((const char*)event->topic, (const uint8_t*)event->data, (size_t&)event->data_len);
|
||||
break;
|
||||
case MQTT_EVENT_ERROR:
|
||||
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_ERROR");
|
||||
if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
|
||||
ESP_LOGI(MQTT_TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ESP_LOGI(MQTT_TAG, "Other event id:%d", event->event_id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool NukiNetwork::reconnect()
|
||||
{
|
||||
_mqttConnectionState = 0;
|
||||
|
||||
while (!_device->mqttConnected() && (esp_timer_get_time() / 1000) > _nextReconnect)
|
||||
if (_mqttConnected)
|
||||
{
|
||||
if(strcmp(_mqttBrokerAddr, "") == 0)
|
||||
Log->println(F("MQTT connected"));
|
||||
_mqttConnectedTs = millis();
|
||||
_mqttConnectionState = 1;
|
||||
delay(100);
|
||||
for(const String& topic : _subscribedTopics)
|
||||
{
|
||||
Log->println(F("MQTT Broker not configured, aborting connection attempt."));
|
||||
_nextReconnect = (esp_timer_get_time() / 1000) + 5000;
|
||||
return false;
|
||||
esp_mqtt_client_subscribe(_mqttClient, topic.c_str(), MQTT_QOS_LEVEL);
|
||||
}
|
||||
|
||||
Log->println(F("Attempting MQTT connection"));
|
||||
|
||||
_connectReplyReceived = false;
|
||||
|
||||
if(strlen(_mqttUser) == 0)
|
||||
if(_firstConnect)
|
||||
{
|
||||
Log->println(F("MQTT: Connecting without credentials"));
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->print(F("MQTT: Connecting with user: ")); Log->println(_mqttUser);
|
||||
_device->mqttSetCredentials(_mqttUser, _mqttPass);
|
||||
}
|
||||
|
||||
_device->setWill(_mqttConnectionStateTopic, 1, true, _lastWillPayload);
|
||||
_device->mqttSetServer(_mqttBrokerAddr, _mqttPort);
|
||||
_device->mqttConnect();
|
||||
|
||||
int64_t timeout = (esp_timer_get_time() / 1000) + 60000;
|
||||
|
||||
while(!_connectReplyReceived && (esp_timer_get_time() / 1000) < timeout)
|
||||
{
|
||||
delay(50);
|
||||
_device->update();
|
||||
if(_keepAliveCallback != nullptr)
|
||||
_firstConnect = false;
|
||||
publishString(_maintenancePathPrefix, mqtt_topic_network_device, _device->deviceName().c_str(), true);
|
||||
for(const auto& it : _initTopics)
|
||||
{
|
||||
_keepAliveCallback();
|
||||
esp_mqtt_client_publish(_mqttClient, it.first.c_str(), it.second.c_str(), 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
}
|
||||
|
||||
if (_device->mqttConnected())
|
||||
{
|
||||
Log->println(F("MQTT connected"));
|
||||
_mqttConnectedTs = millis();
|
||||
_mqttConnectionState = 1;
|
||||
delay(100);
|
||||
_device->mqttOnMessage(NukiNetwork::onMqttDataReceivedCallback);
|
||||
for(const String& topic : _subscribedTopics)
|
||||
{
|
||||
_device->mqttSubscribe(topic.c_str(), MQTT_QOS_LEVEL);
|
||||
}
|
||||
if(_firstConnect)
|
||||
{
|
||||
_firstConnect = false;
|
||||
publishString(_maintenancePathPrefix, mqtt_topic_network_device, _device->deviceName().c_str(), true);
|
||||
for(const auto& it : _initTopics)
|
||||
{
|
||||
_device->mqttPublish(it.first.c_str(), MQTT_QOS_LEVEL, true, it.second.c_str());
|
||||
}
|
||||
}
|
||||
publishString(_maintenancePathPrefix, mqtt_topic_mqtt_connection_state, "online", true);
|
||||
publishString(_maintenancePathPrefix, mqtt_topic_info_nuki_hub_ip, _device->localIP().c_str(), true);
|
||||
|
||||
publishString(_maintenancePathPrefix, mqtt_topic_mqtt_connection_state, "online", true);
|
||||
publishString(_maintenancePathPrefix, mqtt_topic_info_nuki_hub_ip, _device->localIP().c_str(), true);
|
||||
|
||||
_mqttConnectionState = 2;
|
||||
for(const auto& callback : _reconnectedCallbacks)
|
||||
{
|
||||
callback();
|
||||
}
|
||||
}
|
||||
else
|
||||
_mqttConnectionState = 2;
|
||||
for(const auto& callback : _reconnectedCallbacks)
|
||||
{
|
||||
Log->print(F("MQTT connect failed, rc="));
|
||||
_device->printError();
|
||||
_mqttConnectionState = 0;
|
||||
_nextReconnect = (esp_timer_get_time() / 1000) + 5000;
|
||||
//_device->mqttDisconnect(true);
|
||||
callback();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttConnectionState = 0;
|
||||
}
|
||||
return _mqttConnectionState > 0;
|
||||
}
|
||||
|
||||
@@ -683,34 +698,20 @@ void NukiNetwork::registerMqttReceiver(MqttReceiver* receiver)
|
||||
_mqttReceivers.push_back(receiver);
|
||||
}
|
||||
|
||||
void NukiNetwork::onMqttDataReceivedCallback(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total)
|
||||
void NukiNetwork::onMqttDataReceived(const char* topic, const uint8_t* payload, size_t& len)
|
||||
{
|
||||
uint8_t value[800] = {0};
|
||||
if((_mqttConnectedTs == -1 || (millis() - _mqttConnectedTs < 2000)) && topic) return;
|
||||
|
||||
size_t l = min(len, sizeof(value)-1);
|
||||
|
||||
for(int i=0; i<l; i++)
|
||||
{
|
||||
value[i] = payload[i];
|
||||
}
|
||||
|
||||
_inst->onMqttDataReceived(properties, topic, value, len, index, total);
|
||||
}
|
||||
|
||||
void NukiNetwork::onMqttDataReceived(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t& len, size_t& index, size_t& total)
|
||||
{
|
||||
if(_mqttConnectedTs == -1 || (millis() - _mqttConnectedTs < 2000)) return;
|
||||
|
||||
parseGpioTopics(properties, topic, payload, len, index, total);
|
||||
parseGpioTopics(topic, payload, len);
|
||||
|
||||
for(auto receiver : _mqttReceivers)
|
||||
{
|
||||
receiver->onMqttDataReceived(topic, (byte*)payload, index);
|
||||
receiver->onMqttDataReceived(topic, (byte*)payload, len);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void NukiNetwork::parseGpioTopics(const espMqttClientTypes::MessageProperties &properties, const char *topic, const uint8_t *payload, size_t& len, size_t& index, size_t& total)
|
||||
void NukiNetwork::parseGpioTopics(const char *topic, const uint8_t *payload, size_t& len)
|
||||
{
|
||||
char gpioPath[250];
|
||||
buildMqttPath(gpioPath, {_lockPath.c_str(), mqtt_topic_gpio_prefix, mqtt_topic_gpio_pin});
|
||||
@@ -756,11 +757,6 @@ int NukiNetwork::mqttConnectionState()
|
||||
return _mqttConnectionState;
|
||||
}
|
||||
|
||||
bool NukiNetwork::encryptionSupported()
|
||||
{
|
||||
return _device->supportsEncryption();
|
||||
}
|
||||
|
||||
bool NukiNetwork::mqttRecentlyConnected()
|
||||
{
|
||||
return _mqttConnectedTs != -1 && (millis() - _mqttConnectedTs < 6000);
|
||||
@@ -779,7 +775,7 @@ void NukiNetwork::publishFloat(const char* prefix, const char* topic, const floa
|
||||
dtostrf(value, 0, precision, str);
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
_device->mqttPublish(path, MQTT_QOS_LEVEL, retain, str);
|
||||
esp_mqtt_client_publish(_mqttClient, path, str, 0, MQTT_QOS_LEVEL, retain);
|
||||
}
|
||||
|
||||
void NukiNetwork::publishInt(const char* prefix, const char *topic, const int value, bool retain)
|
||||
@@ -788,7 +784,7 @@ void NukiNetwork::publishInt(const char* prefix, const char *topic, const int va
|
||||
itoa(value, str, 10);
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
_device->mqttPublish(path, MQTT_QOS_LEVEL, retain, str);
|
||||
esp_mqtt_client_publish(_mqttClient, path, str, 0, MQTT_QOS_LEVEL, retain);
|
||||
}
|
||||
|
||||
void NukiNetwork::publishUInt(const char* prefix, const char *topic, const unsigned int value, bool retain)
|
||||
@@ -797,7 +793,7 @@ void NukiNetwork::publishUInt(const char* prefix, const char *topic, const unsig
|
||||
utoa(value, str, 10);
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
_device->mqttPublish(path, MQTT_QOS_LEVEL, retain, str);
|
||||
esp_mqtt_client_publish(_mqttClient, path, str, 0, MQTT_QOS_LEVEL, retain);
|
||||
}
|
||||
|
||||
void NukiNetwork::publishULong(const char* prefix, const char *topic, const unsigned long value, bool retain)
|
||||
@@ -806,7 +802,7 @@ void NukiNetwork::publishULong(const char* prefix, const char *topic, const unsi
|
||||
utoa(value, str, 10);
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
_device->mqttPublish(path, MQTT_QOS_LEVEL, retain, str);
|
||||
esp_mqtt_client_publish(_mqttClient, path, str, 0, MQTT_QOS_LEVEL, retain);
|
||||
}
|
||||
|
||||
void NukiNetwork::publishLongLong(const char* prefix, const char *topic, int64_t value, bool retain)
|
||||
@@ -827,7 +823,7 @@ void NukiNetwork::publishLongLong(const char* prefix, const char *topic, int64_t
|
||||
}
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
_device->mqttPublish(path, MQTT_QOS_LEVEL, retain, result);
|
||||
esp_mqtt_client_publish(_mqttClient, path, result, 0, MQTT_QOS_LEVEL, retain);
|
||||
}
|
||||
|
||||
void NukiNetwork::publishBool(const char* prefix, const char *topic, const bool value, bool retain)
|
||||
@@ -836,14 +832,14 @@ void NukiNetwork::publishBool(const char* prefix, const char *topic, const bool
|
||||
str[0] = value ? '1' : '0';
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
_device->mqttPublish(path, MQTT_QOS_LEVEL, retain, str);
|
||||
esp_mqtt_client_publish(_mqttClient, path, str, 0, MQTT_QOS_LEVEL, retain);
|
||||
}
|
||||
|
||||
bool NukiNetwork::publishString(const char* prefix, const char *topic, const char *value, bool retain)
|
||||
{
|
||||
char path[200] = {0};
|
||||
buildMqttPath(path, { prefix, topic });
|
||||
return _device->mqttPublish(path, MQTT_QOS_LEVEL, retain, value) > 0;
|
||||
return esp_mqtt_client_publish(_mqttClient, path, value, 0, MQTT_QOS_LEVEL, retain) > 0;
|
||||
}
|
||||
|
||||
void NukiNetwork::publishHASSConfig(char* deviceType, const char* baseTopic, char* name, char* uidString, const char *softwareVersion, const char *hardwareVersion, const char* availabilityTopic, const bool& hasKeypad, char* lockAction, char* unlockAction, char* openAction)
|
||||
@@ -899,7 +895,7 @@ void NukiNetwork::publishHASSConfig(char* deviceType, const char* baseTopic, cha
|
||||
path.concat(uidString);
|
||||
path.concat("/smartlock/config");
|
||||
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
|
||||
// Battery critical
|
||||
publishHassTopic("binary_sensor",
|
||||
@@ -1755,7 +1751,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][4] = "Intelligent";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "fob_action_1", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1773,7 +1769,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][4] = "Intelligent";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "fob_action_2", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1791,7 +1787,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][4] = "Intelligent";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "fob_action_3", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1808,7 +1804,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][3] = "Slowest";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "advertising_mode", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1869,7 +1865,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "timezone", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2019,7 +2015,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][6] = "Show Status";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "single_button_press_action", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2039,7 +2035,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][6] = "Show Status";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "double_button_press_action", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2083,7 +2079,7 @@ void NukiNetwork::publishHASSConfigAdditionalLockEntities(char *deviceType, cons
|
||||
json["options"][2] = "Lithium";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "battery_type", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2516,7 +2512,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["event_types"][1] = "ringlocked";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("event", "ring", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
|
||||
if((int)basicOpenerConfigAclPrefs[5] == 1)
|
||||
{
|
||||
@@ -2700,7 +2696,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][5] = "Ring";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "fob_action_1", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2719,7 +2715,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][5] = "Ring";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "fob_action_2", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2738,7 +2734,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][5] = "Ring";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "fob_action_3", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2755,7 +2751,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][3] = "Slowest";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "advertising_mode", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2816,7 +2812,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "timezone", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2845,7 +2841,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][15] = "Spare";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "operating_mode", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3055,7 +3051,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][7] = "CM & RTO & Ring";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "doorbell_suppression", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3099,7 +3095,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][3] = "Sound 3";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "sound_ring", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3116,7 +3112,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][3] = "Sound 3";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "sound_open", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3133,7 +3129,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][3] = "Sound 3";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "sound_rto", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3150,7 +3146,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][3] = "Sound 3";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "sound_cm", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3199,7 +3195,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][7] = "Open";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "single_button_press_action", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3220,7 +3216,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][7] = "Open";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "double_button_press_action", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3236,7 +3232,7 @@ void NukiNetwork::publishHASSConfigAdditionalOpenerEntities(char *deviceType, co
|
||||
json["options"][2] = "Lithium";
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath("select", "battery_type", uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3411,7 +3407,7 @@ void NukiNetwork::publishHassTopic(const String& mqttDeviceType,
|
||||
json = createHassJson(uidString, uidStringPostfix, displayName, name, baseTopic, stateTopic, deviceType, deviceClass, stateClass, entityCat, commandTopic, additionalEntries);
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
String path = createHassTopicPath(mqttDeviceType, mqttDeviceName, uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, _buffer);
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), _buffer, 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3434,7 +3430,7 @@ void NukiNetwork::removeHassTopic(const String& mqttDeviceType, const String& mq
|
||||
if (_discoveryTopic != "")
|
||||
{
|
||||
String path = createHassTopicPath(mqttDeviceType, mqttDeviceName, uidString);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), "", 0, MQTT_QOS_LEVEL, 1);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3442,7 +3438,7 @@ void NukiNetwork::removeTopic(const String& mqttPath, const String& mqttTopic)
|
||||
{
|
||||
String path = mqttPath;
|
||||
path.concat(mqttTopic);
|
||||
_device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");
|
||||
esp_mqtt_client_publish(_mqttClient, path.c_str(), "", 0, MQTT_QOS_LEVEL, 1);
|
||||
|
||||
#ifdef DEBUG_NUKIHUB
|
||||
Log->print(F("Removing MQTT topic: "));
|
||||
@@ -3812,7 +3808,7 @@ void NukiNetwork::timeZoneIdToString(const Nuki::TimeZoneId timeZoneId, char* st
|
||||
|
||||
uint16_t NukiNetwork::subscribe(const char *topic, uint8_t qos)
|
||||
{
|
||||
return _device->mqttSubscribe(topic, qos);
|
||||
return esp_mqtt_client_subscribe(_mqttClient, topic, qos);
|
||||
}
|
||||
|
||||
void NukiNetwork::addReconnectedCallback(std::function<void()> reconnectedCallback)
|
||||
@@ -3822,7 +3818,7 @@ void NukiNetwork::addReconnectedCallback(std::function<void()> reconnectedCallba
|
||||
|
||||
void NukiNetwork::disableMqtt()
|
||||
{
|
||||
_device->disableMqtt();
|
||||
esp_mqtt_client_disconnect(_mqttClient);
|
||||
_mqttEnabled = false;
|
||||
}
|
||||
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
#include "MqttReceiver.h"
|
||||
#include "mqtt_client.h"
|
||||
#include "MqttTopics.h"
|
||||
#include "Gpio.h"
|
||||
#include <ArduinoJson.h>
|
||||
@@ -84,7 +85,6 @@ public:
|
||||
void timeZoneIdToString(const Nuki::TimeZoneId timeZoneId, char* str);
|
||||
|
||||
int mqttConnectionState(); // 0 = not connected; 1 = connected; 2 = connected and mqtt processed
|
||||
bool encryptionSupported();
|
||||
bool mqttRecentlyConnected();
|
||||
bool pathEquals(const char* prefix, const char* path, const char* referencePath);
|
||||
uint16_t subscribe(const char* topic, uint8_t qos);
|
||||
@@ -115,9 +115,10 @@ private:
|
||||
bool _offEnabled = false;
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
static void onMqttDataReceivedCallback(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total);
|
||||
void onMqttDataReceived(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t& len, size_t& index, size_t& total);
|
||||
void parseGpioTopics(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t& len, size_t& index, size_t& total);
|
||||
static void mqtt_event_handler_cb(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);
|
||||
void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);
|
||||
void onMqttDataReceived(const char* topic, const uint8_t* payload, size_t& len);
|
||||
void parseGpioTopics(const char* topic, const uint8_t* payload, size_t& len);
|
||||
void gpioActionCallback(const GpioAction& action, const int& pin);
|
||||
|
||||
String createHassTopicPath(const String& mqttDeviceType, const String& mqttDeviceName, const String& uidString);
|
||||
@@ -134,10 +135,6 @@ private:
|
||||
const String& commandTopic = "",
|
||||
std::vector<std::pair<char*, char*>> additionalEntries = {}
|
||||
);
|
||||
|
||||
void onMqttConnect(const bool& sessionPresent);
|
||||
void onMqttDisconnect(const espMqttClientTypes::DisconnectReason& reason);
|
||||
|
||||
void buildMqttPath(char* outPath, std::initializer_list<const char*> paths);
|
||||
|
||||
const char* _lastWillPayload = "offline";
|
||||
@@ -146,13 +143,18 @@ private:
|
||||
String _discoveryTopic;
|
||||
|
||||
Gpio* _gpio;
|
||||
|
||||
|
||||
int _mqttConnectionState = 0;
|
||||
bool _mqttConnected = false;
|
||||
int _mqttConnectCounter = 0;
|
||||
int _mqttPort = 1883;
|
||||
long _mqttConnectedTs = -1;
|
||||
bool _connectReplyReceived = false;
|
||||
bool _firstDisconnected = true;
|
||||
|
||||
esp_mqtt_client_handle_t _mqttClient;
|
||||
char _ca[TLS_CA_MAX_SIZE] = {0};
|
||||
char _cert[TLS_CERT_MAX_SIZE] = {0};
|
||||
char _key[TLS_KEY_MAX_SIZE] = {0};
|
||||
|
||||
int64_t _nextReconnect = 0;
|
||||
char _mqttBrokerAddr[101] = {0};
|
||||
|
||||
@@ -2786,9 +2786,9 @@ esp_err_t WebCfgServer::buildMqttConfigHtml(PsychicRequest *request)
|
||||
printInputField(&response, "HASSDISCOVERY", "Home Assistant discovery topic (empty to disable; usually homeassistant)", _preferences->getString(preference_mqtt_hass_discovery).c_str(), 30, "");
|
||||
printInputField(&response, "HASSCUURL", "Home Assistant device configuration URL (empty to use http://LOCALIP; fill when using a reverse proxy for example)", _preferences->getString(preference_mqtt_hass_cu_url).c_str(), 261, "");
|
||||
if(_preferences->getBool(preference_opener_enabled, false)) printCheckBox(&response, "OPENERCONT", "Set Nuki Opener Lock/Unlock action in Home Assistant to Continuous mode", _preferences->getBool(preference_opener_continuous_mode), "");
|
||||
printTextarea(&response, "MQTTCA", "MQTT SSL CA Certificate (*, optional)", _preferences->getString(preference_mqtt_ca).c_str(), TLS_CA_MAX_SIZE, _network->encryptionSupported(), true);
|
||||
printTextarea(&response, "MQTTCRT", "MQTT SSL Client Certificate (*, optional)", _preferences->getString(preference_mqtt_crt).c_str(), TLS_CERT_MAX_SIZE, _network->encryptionSupported(), true);
|
||||
printTextarea(&response, "MQTTKEY", "MQTT SSL Client Key (*, optional)", _preferences->getString(preference_mqtt_key).c_str(), TLS_KEY_MAX_SIZE, _network->encryptionSupported(), true);
|
||||
printTextarea(&response, "MQTTCA", "MQTT SSL CA Certificate (*, optional)", _preferences->getString(preference_mqtt_ca).c_str(), TLS_CA_MAX_SIZE, true, true);
|
||||
printTextarea(&response, "MQTTCRT", "MQTT SSL Client Certificate (*, optional)", _preferences->getString(preference_mqtt_crt).c_str(), TLS_CERT_MAX_SIZE, true, true);
|
||||
printTextarea(&response, "MQTTKEY", "MQTT SSL Client Key (*, optional)", _preferences->getString(preference_mqtt_key).c_str(), TLS_KEY_MAX_SIZE, true, true);
|
||||
printDropDown(&response, "NWHW", "Network hardware", String(_preferences->getInt(preference_network_hardware)), getNetworkDetectionOptions(), "");
|
||||
#ifndef CONFIG_IDF_TARGET_ESP32H2
|
||||
printCheckBox(&response, "NWHWWIFIFB", "Disable fallback to Wi-Fi / Wi-Fi config portal", _preferences->getBool(preference_network_wifi_fallback_disabled), "");
|
||||
|
||||
@@ -1,10 +1,6 @@
|
||||
#include "EthernetDevice.h"
|
||||
#include "../PreferencesKeys.h"
|
||||
#include "../Logger.h"
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
#include "../MqttTopics.h"
|
||||
#include "espMqttClient.h"
|
||||
#endif
|
||||
#include "../RestartReason.h"
|
||||
|
||||
EthernetDevice::EthernetDevice(const String& hostname, Preferences* preferences, const IPConfiguration* ipConfiguration, const std::string& deviceName, uint8_t phy_addr, int power, int mdc, int mdio, eth_phy_type_t ethtype, eth_clock_mode_t clock_mode)
|
||||
@@ -50,54 +46,6 @@ EthernetDevice::EthernetDevice(const String &hostname,
|
||||
init();
|
||||
}
|
||||
|
||||
void EthernetDevice::init()
|
||||
{
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
size_t caLength = _preferences->getString(preference_mqtt_ca, _ca, TLS_CA_MAX_SIZE);
|
||||
size_t crtLength = _preferences->getString(preference_mqtt_crt, _cert, TLS_CERT_MAX_SIZE);
|
||||
size_t keyLength = _preferences->getString(preference_mqtt_key, _key, TLS_KEY_MAX_SIZE);
|
||||
|
||||
_useEncryption = caLength > 1; // length is 1 when empty
|
||||
|
||||
if(_useEncryption)
|
||||
{
|
||||
Log->println(F("MQTT over TLS."));
|
||||
Log->println(_ca);
|
||||
_mqttClientSecure = new espMqttClientSecure(espMqttClientTypes::UseInternalTask::NO);
|
||||
_mqttClientSecure->setCACert(_ca);
|
||||
if(crtLength > 1 && keyLength > 1) // length is 1 when empty
|
||||
{
|
||||
Log->println(F("MQTT with client certificate."));
|
||||
Log->println(_cert);
|
||||
Log->println(_key);
|
||||
_mqttClientSecure->setCertificate(_cert);
|
||||
_mqttClientSecure->setPrivateKey(_key);
|
||||
}
|
||||
} else
|
||||
{
|
||||
Log->println(F("MQTT without TLS."));
|
||||
_mqttClient = new espMqttClient(espMqttClientTypes::UseInternalTask::NO);
|
||||
}
|
||||
|
||||
if(_preferences->getBool(preference_mqtt_log_enabled, false) || _preferences->getBool(preference_webserial_enabled, false))
|
||||
{
|
||||
MqttLoggerMode mode;
|
||||
|
||||
if(_preferences->getBool(preference_mqtt_log_enabled, false) && _preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::MqttAndSerialAndWeb;
|
||||
else if (_preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::SerialAndWeb;
|
||||
else mode = MqttLoggerMode::MqttAndSerial;
|
||||
|
||||
_path = new char[200];
|
||||
memset(_path, 0, sizeof(_path));
|
||||
|
||||
String pathStr = _preferences->getString(preference_mqtt_lock_path);
|
||||
pathStr.concat(mqtt_topic_log);
|
||||
strcpy(_path, pathStr.c_str());
|
||||
Log = new MqttLogger(*getMqttClient(), _path, mode);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
const String EthernetDevice::deviceName() const
|
||||
{
|
||||
return _deviceName.c_str();
|
||||
@@ -149,8 +97,6 @@ void EthernetDevice::initialize()
|
||||
|
||||
void EthernetDevice::update()
|
||||
{
|
||||
NetworkDevice::update();
|
||||
|
||||
if(_checkIpTs != -1)
|
||||
{
|
||||
if(_ipConfiguration->ipAddress() != ETH.localIP())
|
||||
@@ -221,19 +167,12 @@ void EthernetDevice::onNetworkEvent(arduino_event_id_t event, arduino_event_info
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void EthernetDevice::reconfigure()
|
||||
{
|
||||
delay(200);
|
||||
restartEsp(RestartReason::ReconfigureETH);
|
||||
}
|
||||
|
||||
bool EthernetDevice::supportsEncryption()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
bool EthernetDevice::isConnected()
|
||||
{
|
||||
return _connected;
|
||||
|
||||
@@ -11,9 +11,6 @@
|
||||
#include <NetworkClientSecure.h>
|
||||
#include <Preferences.h>
|
||||
#include "NetworkDevice.h"
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
#include "espMqttClient.h"
|
||||
#endif
|
||||
|
||||
class EthernetDevice : public NetworkDevice
|
||||
{
|
||||
@@ -50,7 +47,6 @@ public:
|
||||
virtual void update();
|
||||
|
||||
virtual ReconnectStatus reconnect(bool force = false);
|
||||
bool supportsEncryption() override;
|
||||
|
||||
virtual bool isConnected();
|
||||
|
||||
@@ -62,12 +58,10 @@ public:
|
||||
private:
|
||||
Preferences* _preferences;
|
||||
|
||||
void init();
|
||||
void onDisconnected();
|
||||
void onNetworkEvent(arduino_event_id_t event, arduino_event_info_t info);
|
||||
|
||||
bool _connected = false;
|
||||
char* _path;
|
||||
bool _hardwareInitialized = false;
|
||||
|
||||
const std::string _deviceName;
|
||||
@@ -91,10 +85,4 @@ private:
|
||||
eth_phy_type_t _type;
|
||||
eth_clock_mode_t _clock_mode;
|
||||
bool _useSpi = false;
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
char _ca[TLS_CA_MAX_SIZE] = {0};
|
||||
char _cert[TLS_CERT_MAX_SIZE] = {0};
|
||||
char _key[TLS_KEY_MAX_SIZE] = {0};
|
||||
#endif
|
||||
};
|
||||
@@ -1,179 +1,6 @@
|
||||
#include <Arduino.h>
|
||||
#include "NetworkDevice.h"
|
||||
#include "../Logger.h"
|
||||
|
||||
void NetworkDevice::printError()
|
||||
{
|
||||
Log->print(F("Free Heap: "));
|
||||
Log->println(ESP.getFreeHeap());
|
||||
}
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
void NetworkDevice::update()
|
||||
{
|
||||
if (_mqttEnabled)
|
||||
{
|
||||
getMqttClient()->loop();
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttSetClientId(const char *clientId)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->setClientId(clientId);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->setClientId(clientId);
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttSetCleanSession(bool cleanSession)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->setCleanSession(cleanSession);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->setCleanSession(cleanSession);
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttSetKeepAlive(uint16_t keepAlive)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->setKeepAlive(keepAlive);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->setKeepAlive(keepAlive);
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t NetworkDevice::mqttPublish(const char *topic, uint8_t qos, bool retain, const char *payload)
|
||||
{
|
||||
return getMqttClient()->publish(topic, qos, retain, payload);
|
||||
}
|
||||
|
||||
uint16_t NetworkDevice::mqttPublish(const char *topic, uint8_t qos, bool retain, const uint8_t *payload, size_t length)
|
||||
{
|
||||
return getMqttClient()->publish(topic, qos, retain, payload, length);
|
||||
}
|
||||
|
||||
bool NetworkDevice::mqttConnected() const
|
||||
{
|
||||
return getMqttClient()->connected();
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttSetServer(const char *host, uint16_t port)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->setServer(host, port);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->setServer(host, port);
|
||||
}
|
||||
}
|
||||
|
||||
bool NetworkDevice::mqttConnect()
|
||||
{
|
||||
return getMqttClient()->connect();
|
||||
}
|
||||
|
||||
bool NetworkDevice::mqttDisconnect(bool force)
|
||||
{
|
||||
return getMqttClient()->disconnect(force);
|
||||
}
|
||||
|
||||
void NetworkDevice::setWill(const char *topic, uint8_t qos, bool retain, const char *payload)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->setWill(topic, qos, retain, payload);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->setWill(topic, qos, retain, payload);
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttSetCredentials(const char *username, const char *password)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->setCredentials(username, password);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->setCredentials(username, password);
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttOnMessage(espMqttClientTypes::OnMessageCallback callback)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->onMessage(callback);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->onMessage(callback);
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttOnConnect(espMqttClientTypes::OnConnectCallback callback)
|
||||
{
|
||||
if(_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->onConnect(callback);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->onConnect(callback);
|
||||
}
|
||||
}
|
||||
|
||||
void NetworkDevice::mqttOnDisconnect(espMqttClientTypes::OnDisconnectCallback callback)
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
_mqttClientSecure->onDisconnect(callback);
|
||||
}
|
||||
else
|
||||
{
|
||||
_mqttClient->onDisconnect(callback);
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t NetworkDevice::mqttSubscribe(const char *topic, uint8_t qos)
|
||||
{
|
||||
return getMqttClient()->subscribe(topic, qos);
|
||||
}
|
||||
|
||||
void NetworkDevice::disableMqtt()
|
||||
{
|
||||
getMqttClient()->disconnect();
|
||||
_mqttEnabled = false;
|
||||
}
|
||||
|
||||
MqttClient *NetworkDevice::getMqttClient() const
|
||||
{
|
||||
if (_useEncryption)
|
||||
{
|
||||
return _mqttClientSecure;
|
||||
}
|
||||
else
|
||||
{
|
||||
return _mqttClient;
|
||||
}
|
||||
}
|
||||
#else
|
||||
void NetworkDevice::update()
|
||||
{
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -1,9 +1,4 @@
|
||||
#pragma once
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
#include "espMqttClient.h"
|
||||
#include "MqttClientSetup.h"
|
||||
#endif
|
||||
#include "IPConfiguration.h"
|
||||
|
||||
enum class ReconnectStatus
|
||||
@@ -26,9 +21,6 @@ public:
|
||||
virtual void initialize() = 0;
|
||||
virtual ReconnectStatus reconnect(bool force = false) = 0;
|
||||
virtual void reconfigure() = 0;
|
||||
virtual void printError();
|
||||
virtual bool supportsEncryption() = 0;
|
||||
|
||||
virtual void update();
|
||||
|
||||
virtual bool isConnected() = 0;
|
||||
@@ -36,38 +28,7 @@ public:
|
||||
|
||||
virtual String localIP() = 0;
|
||||
virtual String BSSIDstr() = 0;
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
virtual void mqttSetClientId(const char* clientId);
|
||||
virtual void mqttSetCleanSession(bool cleanSession);
|
||||
virtual void mqttSetKeepAlive(uint16_t keepAlive);
|
||||
virtual uint16_t mqttPublish(const char* topic, uint8_t qos, bool retain, const char* payload);
|
||||
virtual uint16_t mqttPublish(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length);
|
||||
virtual bool mqttConnected() const;
|
||||
virtual void mqttSetServer(const char* host, uint16_t port);
|
||||
virtual bool mqttConnect();
|
||||
virtual bool mqttDisconnect(bool force);
|
||||
virtual void setWill(const char* topic, uint8_t qos, bool retain, const char* payload);
|
||||
virtual void mqttSetCredentials(const char* username, const char* password);
|
||||
virtual void mqttOnMessage(espMqttClientTypes::OnMessageCallback callback);
|
||||
virtual void mqttOnConnect(espMqttClientTypes::OnConnectCallback callback);
|
||||
virtual void mqttOnDisconnect(espMqttClientTypes::OnDisconnectCallback callback);
|
||||
virtual void disableMqtt();
|
||||
|
||||
virtual uint16_t mqttSubscribe(const char* topic, uint8_t qos);
|
||||
#endif
|
||||
|
||||
protected:
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
espMqttClient *_mqttClient = nullptr;
|
||||
espMqttClientSecure *_mqttClientSecure = nullptr;
|
||||
|
||||
bool _useEncryption = false;
|
||||
bool _mqttEnabled = true;
|
||||
|
||||
MqttClient *getMqttClient() const;
|
||||
#endif
|
||||
|
||||
protected:
|
||||
const String _hostname;
|
||||
const IPConfiguration* _ipConfiguration = nullptr;
|
||||
};
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user