Compare commits

..

14 Commits
v1.3 ... main

Author SHA1 Message Date
a080869c5c Version 1.41
Fixed one bug with generating of message ID.
2023-03-05 15:05:40 +03:00
9c3d35e1c3 Minor changes 2023-02-11 09:35:25 +03:00
49a4bd210d Minor changes 2023-02-11 08:39:58 +03:00
5e0822b8e9 Merge branch 'main' of http://git.zh.com.ru/alexey.zholtikov/ZHNetwork 2023-02-11 08:26:45 +03:00
915e2bf7b7 Minor changes 2023-02-11 08:26:43 +03:00
0812c15b85 Merge branch 'main' of http://git.zh.com.ru/alexey.zholtikov/ZHNetwork 2023-02-11 08:17:36 +03:00
4189c860aa Minor changes 2023-02-11 08:17:28 +03:00
7a8dbe40f0 Merge branch 'main' of http://git.zh.com.ru/alexey.zholtikov/ZHNetwork 2023-02-11 08:16:20 +03:00
6eab8cde49 Minor changes 2023-02-11 08:16:18 +03:00
d94bbe028c Minor Changes 2023-02-10 15:33:49 +03:00
341f314895 Version 1.4
Added simple XOR crypting.
2023-01-19 18:36:57 +03:00
32f7c013b8 Version 1.32
Fixed bug with periodically absence a confirmation message.
2023-01-14 09:27:07 +03:00
62acd2a386 Version 1.31
Added gateway mode support.
2023-01-03 17:55:08 +03:00
506acf1fc0 Minor changes 2022-12-24 13:48:16 +03:00
6 changed files with 164 additions and 41 deletions

View File

@ -4,14 +4,15 @@ A simple library for creating ESP-NOW based Mesh network for ESP8266/ESP32.
## Features
1. The maximum size of transmitted data is 200 bytes. Currently only unencrypted messages.
2. All nodes are not visible to the network scanner (for the ESP_NOW mode only).
3. Not required a pre-pairings for data transfer.
4. Broadcast or unicast data transmission.
5. There are no periodic/synchronous messages on the network. All devices are in "silent mode" and do not "hum" into the air (for the ESP_NOW mode only).
6. Each node has its own independent routing table, updated only as needed.
7. Each node will receive/send a message if it "sees" at least one device on the network.
8. The number of devices on the network and the area of use is not limited (hypothetically). :-)
1. The maximum size of transmitted data is 200 bytes.
2. Encrypted and unencrypted messages. Simple XOR crypting.
3. All nodes are not visible to the network scanner.
4. Not required a pre-pairings for data transfer.
5. Broadcast or unicast data transmissions.
6. There are no periodic/synchronous messages on the network. All devices are in "silent mode" and do not "hum" into the air.
7. Each node has its own independent routing table, updated only as needed.
8. Each node will receive/send a message if it "sees" at least one device on the network.
9. The number of devices on the network and the area of use is not limited (hypothetically). :-)
## Testing
@ -25,7 +26,7 @@ A simple library for creating ESP-NOW based Mesh network for ESP8266/ESP32.
## Notes
1. Possibility uses WiFi AP or STA modes at the same time with ESP-NOW using the standard libraries.
2. For correct work at ESP-NOW + STA mode your WiFi router must be set on channel 1.
2. For correct work at ESP-NOW + STA mode your WiFi router must be set on channel 1 and set gateway mode.
## Function descriptions
@ -59,7 +60,7 @@ Note. Called only at broadcast or unicast with confirm message. Status will alwa
```cpp
myNet.setOnConfirmReceivingCallback(onConfirmReceiving);
void onConfirmReceiving(const uint8_t *target, const bool status)
void onConfirmReceiving(const uint8_t *target, const uint16_t id, const bool status)
{
// Do something when receiving a delivery/undelivery confirm message.
}
@ -73,16 +74,21 @@ Note. If network name not set node will work with all ESP-NOW networks. If set n
```cpp
myNet.begin("ZHNetwork");
myNet.begin("ZHNetwork", true); // Gateway mode.
```
### Sends broadcast message to all nodes
Returns message ID.
```cpp
myNet.sendBroadcastMessage("Hello world!");
```
### Sends unicast message to node
Returns message ID.
```cpp
myNet.sendUnicastMessage("Hello world!", target); // Without confirm.
myNet.sendUnicastMessage("Hello world!", target, true); // With confirm.
@ -121,6 +127,14 @@ uint8_t mac[6]
myNet.stringToMac(string, mac);
```
### Sets crypt key
1-20 characters.
```cpp
myNet.setCryptKey("VERY_LONG_CRYPT_KEY");
```
### Sets max number of attempts to send message
1-10. 3 default value.
@ -170,7 +184,7 @@ myNet.getMaxWaitingTimeForRoutingInfo();
void onBroadcastReceiving(const char *data, const uint8_t *sender);
void onUnicastReceiving(const char *data, const uint8_t *sender);
void onConfirmReceiving(const uint8_t *target, const bool status);
void onConfirmReceiving(const uint8_t *target, const uint16_t id, const bool status);
ZHNetwork myNet;
@ -183,6 +197,7 @@ void setup()
Serial.begin(115200);
Serial.println();
myNet.begin("ZHNetwork");
// myNet.setCryptKey("VERY_LONG_CRYPT_KEY"); // If encryption is used, the key must be set same of all another ESP-NOW devices in network.
myNet.setOnBroadcastReceivingCallback(onBroadcastReceiving);
myNet.setOnUnicastReceivingCallback(onUnicastReceiving);
myNet.setOnConfirmReceivingCallback(onConfirmReceiving);
@ -199,14 +214,18 @@ void loop()
{
Serial.println("Broadcast message sended.");
myNet.sendBroadcastMessage("Hello world!");
Serial.print("Unicast message to MAC ");
Serial.print(myNet.macToString(target));
Serial.println(" sended.");
myNet.sendUnicastMessage("Hello world!", target);
Serial.print("Unicast with confirm message to MAC ");
Serial.print(myNet.macToString(target));
Serial.print(" ID ");
Serial.print(myNet.sendUnicastMessage("Hello world!", target, true));
Serial.println(" sended.");
myNet.sendUnicastMessage("Hello world!", target, true);
messageLastTime = millis();
}
myNet.maintenance();
@ -220,6 +239,7 @@ void onBroadcastReceiving(const char *data, const uint8_t *sender)
Serial.print("Message: ");
Serial.println(data);
}
void onUnicastReceiving(const char *data, const uint8_t *sender)
{
Serial.print("Unicast message from MAC ");
@ -229,10 +249,14 @@ void onUnicastReceiving(const char *data, const uint8_t *sender)
Serial.println(data);
}
void onConfirmReceiving(const uint8_t *target, const bool status)
void onConfirmReceiving(const uint8_t *target, const uint16_t id, const bool status)
{
Serial.print("Message to MAC ");
Serial.print(myNet.macToString(target));
Serial.print(" ID ");
Serial.print(id);
Serial.println(status ? " delivered." : " undelivered.");
}
```
Any feedback via [e-mail](mailto:github@zh.com.ru) would be appreciated. Or... [Buy me a coffee](https://paypal.me/aZholtikov).

View File

@ -10,6 +10,7 @@ void setup()
Serial.begin(115200);
Serial.println();
myNet.begin("ZHNetwork");
// myNet.setCryptKey("VERY_LONG_CRYPT_KEY"); // If encryption is used, the key must be set same of all another ESP-NOW devices in network.
myNet.setOnBroadcastReceivingCallback(onBroadcastReceiving);
myNet.setOnUnicastReceivingCallback(onUnicastReceiving);
Serial.print("MAC: ");
@ -32,6 +33,7 @@ void onBroadcastReceiving(const char *data, const uint8_t *sender)
Serial.print("Message: ");
Serial.println(data);
}
void onUnicastReceiving(const char *data, const uint8_t *sender)
{
Serial.print("Unicast message from MAC ");

View File

@ -1,6 +1,6 @@
#include "ZHNetwork.h"
void onConfirmReceiving(const uint8_t *target, const bool status);
void onConfirmReceiving(const uint8_t *target, const uint16_t id, const bool status);
ZHNetwork myNet;
@ -13,6 +13,7 @@ void setup()
Serial.begin(115200);
Serial.println();
myNet.begin("ZHNetwork");
// myNet.setCryptKey("VERY_LONG_CRYPT_KEY"); // If encryption is used, the key must be set same of all another ESP-NOW devices in network.
myNet.setOnConfirmReceivingCallback(onConfirmReceiving);
Serial.print("MAC: ");
Serial.print(myNet.getNodeMac());
@ -27,22 +28,28 @@ void loop()
{
Serial.println("Broadcast message sended.");
myNet.sendBroadcastMessage("Hello world!");
Serial.print("Unicast message to MAC ");
Serial.print(myNet.macToString(target));
Serial.println(" sended.");
myNet.sendUnicastMessage("Hello world!", target);
Serial.print("Unicast with confirm message to MAC ");
Serial.print(myNet.macToString(target));
Serial.print(" ID ");
Serial.print(myNet.sendUnicastMessage("Hello world!", target, true));
Serial.println(" sended.");
myNet.sendUnicastMessage("Hello world!", target, true);
messageLastTime = millis();
}
myNet.maintenance();
}
void onConfirmReceiving(const uint8_t *target, const bool status)
void onConfirmReceiving(const uint8_t *target, const uint16_t id, const bool status)
{
Serial.print("Message to MAC ");
Serial.print(myNet.macToString(target));
Serial.print(" ID ");
Serial.print(id);
Serial.println(status ? " delivered." : " undelivered.");
}

View File

@ -1,5 +1,5 @@
name=ZHNetwork
version=1.3
version=1.41
author=Alexey Zholtikov
maintainer=Alexey Zholtikov
sentence=ESP-NOW based Mesh network for ESP8266/ESP32

View File

@ -1,6 +1,7 @@
#include "ZHNetwork.h"
routing_vector_t ZHNetwork::routingVector;
confirmation_vector_t ZHNetwork::confirmationVector;
incoming_queue_t ZHNetwork::queueForIncomingData;
outgoing_queue_t ZHNetwork::queueForOutgoingData;
waiting_queue_t ZHNetwork::queueForRoutingVectorWaiting;
@ -10,6 +11,7 @@ bool ZHNetwork::sentMessageSemaphore{false};
bool ZHNetwork::confirmReceivingSemaphore{false};
bool ZHNetwork::confirmReceiving{false};
char ZHNetwork::netName_[20]{0};
char ZHNetwork::key_[20]{0};
uint8_t ZHNetwork::localMAC[6]{0};
uint16_t ZHNetwork::lastMessageID[10]{0};
@ -31,36 +33,41 @@ ZHNetwork &ZHNetwork::setOnConfirmReceivingCallback(on_confirm_t onConfirmReceiv
return *this;
}
error_code_t ZHNetwork::begin(const char *netName)
error_code_t ZHNetwork::begin(const char *netName, const bool gateway)
{
randomSeed(analogRead(0));
if (strlen(netName) > 1 && strlen(netName) < 20)
#if defined(ESP8266)
randomSeed(os_random());
#endif
#if defined(ESP32)
randomSeed(esp_random());
#endif
if (strlen(netName) >= 1 && strlen(netName) <= 20)
strcpy(netName_, netName);
#ifdef PRINT_LOG
Serial.begin(115200);
#endif
WiFi.mode(WIFI_STA);
WiFi.mode(gateway ? WIFI_AP_STA : WIFI_STA);
esp_now_init();
#if defined(ESP8266)
wifi_get_macaddr(STATION_IF, localMAC);
wifi_get_macaddr(gateway ? SOFTAP_IF : STATION_IF, localMAC);
esp_now_set_self_role(ESP_NOW_ROLE_COMBO);
#endif
#if defined(ESP32)
esp_wifi_get_mac((wifi_interface_t)ESP_IF_WIFI_STA, localMAC);
esp_wifi_get_mac(gateway ? (wifi_interface_t)ESP_IF_WIFI_AP : (wifi_interface_t)ESP_IF_WIFI_STA, localMAC);
#endif
esp_now_register_send_cb(onDataSent);
esp_now_register_recv_cb(onDataReceive);
return SUCCESS;
}
void ZHNetwork::sendBroadcastMessage(const char *data)
uint16_t ZHNetwork::sendBroadcastMessage(const char *data)
{
broadcastMessage(data, broadcastMAC, BROADCAST);
return broadcastMessage(data, broadcastMAC, BROADCAST);
}
void ZHNetwork::sendUnicastMessage(const char *data, const uint8_t *target, const bool confirm)
uint16_t ZHNetwork::sendUnicastMessage(const char *data, const uint8_t *target, const bool confirm)
{
unicastMessage(data, target, localMAC, confirm ? UNICAST_WITH_CONFIRM : UNICAST);
return unicastMessage(data, target, localMAC, confirm ? UNICAST_WITH_CONFIRM : UNICAST);
}
void ZHNetwork::maintenance()
@ -80,7 +87,15 @@ void ZHNetwork::maintenance()
esp_now_del_peer(outgoingData.intermediateTargetMAC);
#endif
if (onConfirmReceivingCallback && macToString(outgoingData.transmittedData.originalSenderMAC) == macToString(localMAC) && outgoingData.transmittedData.messageType == BROADCAST)
onConfirmReceivingCallback(outgoingData.transmittedData.originalTargetMAC, true);
onConfirmReceivingCallback(outgoingData.transmittedData.originalTargetMAC, outgoingData.transmittedData.messageID, true);
if (macToString(outgoingData.transmittedData.originalSenderMAC) == macToString(localMAC) && outgoingData.transmittedData.messageType == UNICAST_WITH_CONFIRM)
{
confirmation_waiting_data_t confirmationData;
confirmationData.time = millis();
memcpy(&confirmationData.targetMAC, &outgoingData.transmittedData.originalTargetMAC, 6);
memcpy(&confirmationData.messageID, &outgoingData.transmittedData.messageID, 2);
confirmationVector.push_back(confirmationData);
}
}
else
{
@ -183,7 +198,12 @@ void ZHNetwork::maintenance()
Serial.println(F(" received."));
#endif
if (onBroadcastReceivingCallback)
{
if (key_[0])
for (uint8_t i{0}; i < strlen(incomingData.transmittedData.message); ++i)
incomingData.transmittedData.message[i] = incomingData.transmittedData.message[i] ^ key_[i % strlen(key_)];
onBroadcastReceivingCallback(incomingData.transmittedData.message, incomingData.transmittedData.originalSenderMAC);
}
forward = true;
break;
case UNICAST:
@ -199,7 +219,12 @@ void ZHNetwork::maintenance()
if (macToString(incomingData.transmittedData.originalTargetMAC) == macToString(localMAC))
{
if (onUnicastReceivingCallback)
{
if (key_[0])
for (uint8_t i{0}; i < strlen(incomingData.transmittedData.message); ++i)
incomingData.transmittedData.message[i] = incomingData.transmittedData.message[i] ^ key_[i % strlen(key_)];
onUnicastReceivingCallback(incomingData.transmittedData.message, incomingData.transmittedData.originalSenderMAC);
}
}
else
unicastMessage(incomingData.transmittedData.message, incomingData.transmittedData.originalTargetMAC, incomingData.transmittedData.originalSenderMAC, UNICAST);
@ -217,8 +242,17 @@ void ZHNetwork::maintenance()
if (macToString(incomingData.transmittedData.originalTargetMAC) == macToString(localMAC))
{
if (onUnicastReceivingCallback)
{
if (key_[0])
for (uint8_t i{0}; i < strlen(incomingData.transmittedData.message); ++i)
incomingData.transmittedData.message[i] = incomingData.transmittedData.message[i] ^ key_[i % strlen(key_)];
onUnicastReceivingCallback(incomingData.transmittedData.message, incomingData.transmittedData.originalSenderMAC);
unicastMessage("", incomingData.transmittedData.originalSenderMAC, localMAC, DELIVERY_CONFIRM_RESPONSE);
}
confirmation_id_t id;
memcpy(&id.messageID, &incomingData.transmittedData.messageID, 2);
char temp[sizeof(transmitted_data_t::message)];
memcpy(&temp, &id, sizeof(transmitted_data_t::message));
unicastMessage(temp, incomingData.transmittedData.originalSenderMAC, localMAC, DELIVERY_CONFIRM_RESPONSE);
}
else
unicastMessage(incomingData.transmittedData.message, incomingData.transmittedData.originalTargetMAC, incomingData.transmittedData.originalSenderMAC, UNICAST_WITH_CONFIRM);
@ -236,7 +270,17 @@ void ZHNetwork::maintenance()
if (macToString(incomingData.transmittedData.originalTargetMAC) == macToString(localMAC))
{
if (onConfirmReceivingCallback)
onConfirmReceivingCallback(incomingData.transmittedData.originalSenderMAC, true);
{
confirmation_id_t id;
memcpy(&id.messageID, &incomingData.transmittedData.message, 2);
for (uint16_t i{0}; i < confirmationVector.size(); ++i)
{
confirmation_waiting_data_t confirmationData = confirmationVector[i];
if (confirmationData.messageID == id.messageID)
confirmationVector.erase(confirmationVector.begin() + i);
}
onConfirmReceivingCallback(incomingData.transmittedData.originalSenderMAC, id.messageID, true);
}
}
else
unicastMessage(incomingData.transmittedData.message, incomingData.transmittedData.originalTargetMAC, incomingData.transmittedData.originalSenderMAC, DELIVERY_CONFIRM_RESPONSE);
@ -374,7 +418,21 @@ void ZHNetwork::maintenance()
#endif
if (waitingData.transmittedData.messageType == UNICAST_WITH_CONFIRM && macToString(waitingData.transmittedData.originalSenderMAC) == macToString(localMAC))
if (onConfirmReceivingCallback)
onConfirmReceivingCallback(waitingData.transmittedData.originalTargetMAC, false);
onConfirmReceivingCallback(waitingData.transmittedData.originalTargetMAC, waitingData.transmittedData.messageID, false);
}
}
if (confirmationVector.size())
{
for (uint16_t i{0}; i < confirmationVector.size(); ++i)
{
confirmation_waiting_data_t confirmationData = confirmationVector[i];
if ((millis() - confirmationData.time) > maxTimeForRoutingInfoWaiting_)
{
confirmationVector.erase(confirmationVector.begin() + i);
broadcastMessage("", confirmationData.targetMAC, SEARCH_REQUEST);
if (onConfirmReceivingCallback)
onConfirmReceivingCallback(confirmationData.targetMAC, confirmationData.messageID, false);
}
}
}
}
@ -411,6 +469,13 @@ uint8_t *ZHNetwork::stringToMac(const String &string, uint8_t *mac)
return mac;
}
error_code_t ZHNetwork::setCryptKey(const char *key)
{
if (strlen(key) >= 1 && strlen(key) <= 20)
strcpy(key_, key);
return SUCCESS;
}
error_code_t ZHNetwork::setMaxNumberOfAttempts(const uint8_t maxNumberOfAttempts)
{
if (maxNumberOfAttempts < 1 || maxNumberOfAttempts > 10)
@ -505,7 +570,7 @@ void IRAM_ATTR ZHNetwork::onDataReceive(uint8_t *mac, uint8_t *data, uint8_t len
criticalProcessSemaphore = false;
}
void ZHNetwork::broadcastMessage(const char *data, const uint8_t *target, message_type_t type)
uint16_t ZHNetwork::broadcastMessage(const char *data, const uint8_t *target, message_type_t type)
{
outgoing_data_t outgoingData;
outgoingData.transmittedData.messageType = type;
@ -514,6 +579,9 @@ void ZHNetwork::broadcastMessage(const char *data, const uint8_t *target, messag
memcpy(&outgoingData.transmittedData.originalTargetMAC, target, 6);
memcpy(&outgoingData.transmittedData.originalSenderMAC, &localMAC, 6);
strcpy(outgoingData.transmittedData.message, data);
if (key_[0] && outgoingData.transmittedData.messageType == BROADCAST)
for (uint8_t i{0}; i < strlen(outgoingData.transmittedData.message); ++i)
outgoingData.transmittedData.message[i] = outgoingData.transmittedData.message[i] ^ key_[i % strlen(key_)];
memcpy(&outgoingData.intermediateTargetMAC, &broadcastMAC, 6);
queueForOutgoingData.push(outgoingData);
#ifdef PRINT_LOG
@ -537,9 +605,10 @@ void ZHNetwork::broadcastMessage(const char *data, const uint8_t *target, messag
Serial.print(macToString(outgoingData.transmittedData.originalTargetMAC));
Serial.println(F(" added to queue."));
#endif
return outgoingData.transmittedData.messageID;
}
void ZHNetwork::unicastMessage(const char *data, const uint8_t *target, const uint8_t *sender, message_type_t type)
uint16_t ZHNetwork::unicastMessage(const char *data, const uint8_t *target, const uint8_t *sender, message_type_t type)
{
outgoing_data_t outgoingData;
outgoingData.transmittedData.messageType = type;
@ -548,6 +617,9 @@ void ZHNetwork::unicastMessage(const char *data, const uint8_t *target, const ui
memcpy(&outgoingData.transmittedData.originalTargetMAC, target, 6);
memcpy(&outgoingData.transmittedData.originalSenderMAC, sender, 6);
strcpy(outgoingData.transmittedData.message, data);
if (key_[0] && macToString(outgoingData.transmittedData.originalSenderMAC) == macToString(localMAC) && outgoingData.transmittedData.messageType != DELIVERY_CONFIRM_RESPONSE)
for (uint8_t i{0}; i < strlen(outgoingData.transmittedData.message); ++i)
outgoingData.transmittedData.message[i] = outgoingData.transmittedData.message[i] ^ key_[i % strlen(key_)];
for (uint16_t i{0}; i < routingVector.size(); ++i)
{
routing_table_t routingTable = routingVector[i];
@ -583,7 +655,7 @@ void ZHNetwork::unicastMessage(const char *data, const uint8_t *target, const ui
Serial.print(macToString(outgoingData.intermediateTargetMAC));
Serial.println(F(" added to queue."));
#endif
return;
return outgoingData.transmittedData.messageID;
}
}
memcpy(&outgoingData.intermediateTargetMAC, target, 6);
@ -616,4 +688,5 @@ void ZHNetwork::unicastMessage(const char *data, const uint8_t *target, const ui
Serial.print(macToString(outgoingData.intermediateTargetMAC));
Serial.println(F(" added to queue."));
#endif
return outgoingData.transmittedData.messageID;
}

View File

@ -50,6 +50,19 @@ typedef struct
uint8_t intermediateTargetMAC[6]{0};
} routing_table_t;
typedef struct
{
uint16_t messageID{0};
char empty[198]{0}; // Just only to prevent compiler warnings.
} confirmation_id_t;
typedef struct
{
uint64_t time{0};
uint8_t targetMAC[6]{0};
uint16_t messageID{0};
} confirmation_waiting_data_t;
typedef enum
{
BROADCAST = 1,
@ -67,8 +80,9 @@ typedef enum // Just for further development.
} error_code_t;
typedef std::function<void(const char *, const uint8_t *)> on_message_t;
typedef std::function<void(const uint8_t *, const bool)> on_confirm_t;
typedef std::function<void(const uint8_t *, const uint16_t, const bool)> on_confirm_t;
typedef std::vector<routing_table_t> routing_vector_t;
typedef std::vector<confirmation_waiting_data_t> confirmation_vector_t;
typedef std::queue<outgoing_data_t> outgoing_queue_t;
typedef std::queue<incoming_data_t> incoming_queue_t;
typedef std::queue<waiting_data_t> waiting_queue_t;
@ -80,10 +94,10 @@ public:
ZHNetwork &setOnUnicastReceivingCallback(on_message_t onUnicastReceivingCallback);
ZHNetwork &setOnConfirmReceivingCallback(on_confirm_t onConfirmReceivingCallback);
error_code_t begin(const char *netName = "");
error_code_t begin(const char *netName = "", const bool gateway = false);
void sendBroadcastMessage(const char *data);
void sendUnicastMessage(const char *data, const uint8_t *target, const bool confirm = false);
uint16_t sendBroadcastMessage(const char *data);
uint16_t sendUnicastMessage(const char *data, const uint8_t *target, const bool confirm = false);
void maintenance(void);
@ -94,6 +108,7 @@ public:
static String macToString(const uint8_t *mac);
uint8_t *stringToMac(const String &string, uint8_t *mac);
error_code_t setCryptKey(const char *key = "");
error_code_t setMaxNumberOfAttempts(const uint8_t maxNumberOfAttempts);
uint8_t getMaxNumberOfAttempts(void);
error_code_t setMaxWaitingTimeBetweenTransmissions(const uint8_t maxWaitingTimeBetweenTransmissions);
@ -103,6 +118,7 @@ public:
private:
static routing_vector_t routingVector;
static confirmation_vector_t confirmationVector;
static incoming_queue_t queueForIncomingData;
static outgoing_queue_t queueForOutgoingData;
static waiting_queue_t queueForRoutingVectorWaiting;
@ -114,8 +130,9 @@ private:
static uint8_t localMAC[6];
static uint16_t lastMessageID[10];
static char netName_[20];
static char key_[20];
const char *firmware{"1.3"};
const char *firmware{"1.41"};
const uint8_t broadcastMAC[6]{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t maxNumberOfAttempts_{3};
uint8_t maxWaitingTimeBetweenTransmissions_{50};
@ -131,8 +148,8 @@ private:
static void onDataSent(const uint8_t *mac, esp_now_send_status_t status);
static void onDataReceive(const uint8_t *mac, const uint8_t *data, int length);
#endif
void broadcastMessage(const char *data, const uint8_t *target, message_type_t type);
void unicastMessage(const char *data, const uint8_t *target, const uint8_t *sender, message_type_t type);
uint16_t broadcastMessage(const char *data, const uint8_t *target, message_type_t type);
uint16_t unicastMessage(const char *data, const uint8_t *target, const uint8_t *sender, message_type_t type);
on_message_t onBroadcastReceivingCallback;
on_message_t onUnicastReceivingCallback;
on_confirm_t onConfirmReceivingCallback;