Merge remote-tracking branch 'upstream/main' into add-uf2reset-cli
This commit is contained in:
commit
eb104e4100
408 files changed
+11598
-3622
No files matched your search
+2
-1
@@ -193,8 +193,9 @@ public:
|
||||
bool millisHasNowPassed(unsigned long timestamp) const;
|
||||
unsigned long futureMillis(int millis_from_now) const;
|
||||
|
||||
private:
|
||||
bool tryParsePacket(Packet* pkt, const uint8_t* raw, int len);
|
||||
|
||||
private:
|
||||
void checkRecv();
|
||||
void checkSend();
|
||||
};
|
||||
|
||||
+11
-12
@@ -50,7 +50,9 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
|
||||
uint8_t path_sz = flags & 0x03; // NEW v1.11+: lower 2 bits is path hash size
|
||||
|
||||
uint8_t len = pkt->payload_len - i;
|
||||
uint8_t offset = pkt->path_len << path_sz;
|
||||
// path_len*entry_size can exceed 255 (path_len up to 63, entry_size up to 8);
|
||||
// a uint8_t offset would wrap and steer the isHashMatch() read to the wrong place.
|
||||
uint16_t offset = (uint16_t)pkt->path_len << path_sz;
|
||||
if (offset >= len) { // TRACE has reached end of given path
|
||||
onTraceRecv(pkt, trace_tag, auth_code, flags, pkt->path, &pkt->payload[i], len);
|
||||
} else if (self_id.isHashMatch(&pkt->payload[i + offset], 1 << path_sz) && allowPacketForward(pkt) && !_tables->hasSeen(pkt)) {
|
||||
@@ -361,13 +363,10 @@ DispatcherAction Mesh::forwardMultipartDirect(Packet* pkt) {
|
||||
|
||||
void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {
|
||||
if (!packet->isMarkedDoNotRetransmit()) {
|
||||
uint32_t crc;
|
||||
memcpy(&crc, packet->payload, 4);
|
||||
|
||||
uint8_t extra = getExtraAckTransmitCount();
|
||||
while (extra > 0) {
|
||||
delay_millis += getDirectRetransmitDelay(packet) + 300;
|
||||
auto a1 = createMultiAck(crc, extra);
|
||||
auto a1 = createMultiAck(packet->payload, packet->payload_len, extra);
|
||||
if (a1) {
|
||||
a1->path_len = Packet::copyPath(a1->path, packet->path, packet->path_len);
|
||||
a1->header &= ~PH_ROUTE_MASK;
|
||||
@@ -377,7 +376,7 @@ void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {
|
||||
extra--;
|
||||
}
|
||||
|
||||
auto a2 = createAck(crc);
|
||||
auto a2 = createAck(packet->payload, packet->payload_len);
|
||||
if (a2) {
|
||||
a2->path_len = Packet::copyPath(a2->path, packet->path, packet->path_len);
|
||||
a2->header &= ~PH_ROUTE_MASK;
|
||||
@@ -543,7 +542,7 @@ Packet* Mesh::createGroupDatagram(uint8_t type, const GroupChannel& channel, con
|
||||
return packet;
|
||||
}
|
||||
|
||||
Packet* Mesh::createAck(uint32_t ack_crc) {
|
||||
Packet* Mesh::createAck(const uint8_t* ack, uint8_t len) {
|
||||
Packet* packet = obtainNewPacket();
|
||||
if (packet == NULL) {
|
||||
MESH_DEBUG_PRINTLN("%s Mesh::createAck(): error, packet pool empty", getLogDateTime());
|
||||
@@ -551,13 +550,13 @@ Packet* Mesh::createAck(uint32_t ack_crc) {
|
||||
}
|
||||
packet->header = (PAYLOAD_TYPE_ACK << PH_TYPE_SHIFT); // ROUTE_TYPE_* set later
|
||||
|
||||
memcpy(packet->payload, &ack_crc, 4);
|
||||
packet->payload_len = 4;
|
||||
memcpy(packet->payload, ack, len);
|
||||
packet->payload_len = len;
|
||||
|
||||
return packet;
|
||||
}
|
||||
|
||||
Packet* Mesh::createMultiAck(uint32_t ack_crc, uint8_t remaining) {
|
||||
Packet* Mesh::createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining) {
|
||||
Packet* packet = obtainNewPacket();
|
||||
if (packet == NULL) {
|
||||
MESH_DEBUG_PRINTLN("%s Mesh::createMultiAck(): error, packet pool empty", getLogDateTime());
|
||||
@@ -566,8 +565,8 @@ Packet* Mesh::createMultiAck(uint32_t ack_crc, uint8_t remaining) {
|
||||
packet->header = (PAYLOAD_TYPE_MULTIPART << PH_TYPE_SHIFT); // ROUTE_TYPE_* set later
|
||||
|
||||
packet->payload[0] = (remaining << 4) | PAYLOAD_TYPE_ACK;
|
||||
memcpy(&packet->payload[1], &ack_crc, 4);
|
||||
packet->payload_len = 5;
|
||||
memcpy(&packet->payload[1], ack, len);
|
||||
packet->payload_len = 1 + len;
|
||||
|
||||
return packet;
|
||||
}
|
||||
|
||||
+9
-7
@@ -45,7 +45,7 @@ protected:
|
||||
|
||||
/**
|
||||
* \brief Called _before_ the packet is dispatched to the on..Recv() methods.
|
||||
* \returns true, if given packet should be NOT be processed.
|
||||
* \returns true, if given packet should NOT be processed.
|
||||
*/
|
||||
virtual bool filterRecvFloodPacket(Packet* packet) { return false; }
|
||||
|
||||
@@ -107,7 +107,7 @@ protected:
|
||||
|
||||
/**
|
||||
* \brief A path TO peer (sender_idx) has been received. (also with optional 'extra' data encoded)
|
||||
* NOTE: these can be received multiple times (per sender), via differen routes
|
||||
* NOTE: these can be received multiple times (per sender), via different routes
|
||||
* \param sender_idx index of peer, [0..n) where n is what searchPeersByHash() returned
|
||||
* \param secret the pre-calculated shared-secret (handy for sending response packet)
|
||||
* \returns true, if path was accepted and that reciprocal path should be sent
|
||||
@@ -130,7 +130,7 @@ protected:
|
||||
|
||||
/**
|
||||
* \brief A path TO 'sender' has been received. (also with optional 'extra' data encoded)
|
||||
* NOTE: these can be received multiple times (per sender), via differen routes
|
||||
* NOTE: these can be received multiple times (per sender), via different routes
|
||||
*/
|
||||
virtual void onPathRecv(Packet* packet, Identity& sender, uint8_t* path, uint8_t path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) { }
|
||||
|
||||
@@ -185,8 +185,10 @@ public:
|
||||
Packet* createDatagram(uint8_t type, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t len);
|
||||
Packet* createAnonDatagram(uint8_t type, const LocalIdentity& sender, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t data_len);
|
||||
Packet* createGroupDatagram(uint8_t type, const GroupChannel& channel, const uint8_t* data, size_t data_len);
|
||||
Packet* createAck(uint32_t ack_crc);
|
||||
Packet* createMultiAck(uint32_t ack_crc, uint8_t remaining);
|
||||
Packet* createAck(const uint8_t* ack, uint8_t len);
|
||||
Packet* createAck(uint32_t ack_crc) { return createAck((uint8_t *) &ack_crc, 4); }
|
||||
Packet* createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining);
|
||||
Packet* createMultiAck(uint32_t ack_crc, uint8_t remaining) { return createMultiAck((uint8_t *)&ack_crc, 4, remaining); }
|
||||
Packet* createPathReturn(const uint8_t* dest_hash, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
|
||||
Packet* createPathReturn(const Identity& dest, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
|
||||
Packet* createRawData(const uint8_t* data, size_t len);
|
||||
@@ -210,12 +212,12 @@ public:
|
||||
void sendDirect(Packet* packet, const uint8_t* path, uint8_t path_len, uint32_t delay_millis=0);
|
||||
|
||||
/**
|
||||
* \brief send a locally-generated Packet to just neigbor nodes (zero hops)
|
||||
* \brief send a locally-generated Packet to just neighbor nodes (zero hops)
|
||||
*/
|
||||
void sendZeroHop(Packet* packet, uint32_t delay_millis=0);
|
||||
|
||||
/**
|
||||
* \brief send a locally-generated Packet to just neigbor nodes (zero hops), with specific transort codes
|
||||
* \brief send a locally-generated Packet to just neighbor nodes (zero hops), with specific transport codes
|
||||
* \param transport_codes array of 2 codes to attach to packet
|
||||
*/
|
||||
void sendZeroHop(Packet* packet, uint16_t* transport_codes, uint32_t delay_millis=0);
|
||||
|
||||
+8
-1
@@ -1,6 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <math.h>
|
||||
|
||||
#define MAX_HASH_SIZE 8
|
||||
@@ -17,6 +18,7 @@
|
||||
#define PATH_HASH_SIZE 1
|
||||
|
||||
#define MAX_PACKET_PAYLOAD 184
|
||||
#define MAX_GROUP_DATA_LENGTH (MAX_PACKET_PAYLOAD - CIPHER_BLOCK_SIZE - 3)
|
||||
#define MAX_PATH_SIZE 64
|
||||
#define MAX_TRANS_UNIT 255
|
||||
|
||||
@@ -51,6 +53,11 @@ public:
|
||||
virtual void onAfterTransmit() { }
|
||||
virtual void reboot() = 0;
|
||||
virtual void powerOff() { /* no op */ }
|
||||
// Called by example setup() functions to signal that boot is complete.
|
||||
// Boards may override to stop a boot-indicator LED sequence or similar.
|
||||
// Default no-op: boards that don't care need not implement anything.
|
||||
virtual void onBootComplete() { /* no op */ }
|
||||
virtual uint32_t getIRQGpio() { return -1; } // not supported. Returns DIO1 (SX1262) and DIO0 (SX127x)
|
||||
virtual void sleep(uint32_t secs) { /* no op */ }
|
||||
virtual uint32_t getGpio() { return 0; }
|
||||
virtual void setGpio(uint32_t values) {}
|
||||
@@ -100,4 +107,4 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -22,7 +22,7 @@ namespace mesh {
|
||||
#define PAYLOAD_TYPE_ACK 0x03 // a simple ack
|
||||
#define PAYLOAD_TYPE_ADVERT 0x04 // a node advertising its Identity
|
||||
#define PAYLOAD_TYPE_GRP_TXT 0x05 // an (unverified) group text message (prefixed with channel hash, MAC) (enc data: timestamp, "name: msg")
|
||||
#define PAYLOAD_TYPE_GRP_DATA 0x06 // an (unverified) group datagram (prefixed with channel hash, MAC) (enc data: timestamp, blob)
|
||||
#define PAYLOAD_TYPE_GRP_DATA 0x06 // an (unverified) group datagram (prefixed with channel hash, MAC) (enc data: data_type(uint16), data_len, blob)
|
||||
#define PAYLOAD_TYPE_ANON_REQ 0x07 // generic request (prefixed with dest_hash, ephemeral pub_key, MAC) (enc data: ...)
|
||||
#define PAYLOAD_TYPE_PATH 0x08 // returned path (prefixed with dest/src hashes, MAC) (enc data: path, extra)
|
||||
#define PAYLOAD_TYPE_TRACE 0x09 // trace a path, collecting SNI for each hop
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "AutoDiscoverRTCClock.h"
|
||||
#include "RTClib.h"
|
||||
#include <Melopero_RV3028.h>
|
||||
#include "RTC_RX8130CE.h"
|
||||
|
||||
static RTC_DS3231 rtc_3231;
|
||||
static bool ds3231_success = false;
|
||||
@@ -11,9 +12,13 @@ static bool rv3028_success = false;
|
||||
static RTC_PCF8563 rtc_8563;
|
||||
static bool rtc_8563_success = false;
|
||||
|
||||
static RTC_RX8130CE rtc_8130;
|
||||
static bool rtc_8130_success = false;
|
||||
|
||||
#define DS3231_ADDRESS 0x68
|
||||
#define RV3028_ADDRESS 0x52
|
||||
#define PCF8563_ADDRESS 0x51
|
||||
#define RX8130CE_ADDRESS 0x32
|
||||
|
||||
bool AutoDiscoverRTCClock::i2c_probe(TwoWire& wire, uint8_t addr) {
|
||||
wire.beginTransmission(addr);
|
||||
@@ -22,25 +27,37 @@ bool AutoDiscoverRTCClock::i2c_probe(TwoWire& wire, uint8_t addr) {
|
||||
}
|
||||
|
||||
void AutoDiscoverRTCClock::begin(TwoWire& wire) {
|
||||
#if !defined(DISABLE_DS3231_PROBE)
|
||||
if (i2c_probe(wire, DS3231_ADDRESS)) {
|
||||
ds3231_success = rtc_3231.begin(&wire);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (i2c_probe(wire, RV3028_ADDRESS)) {
|
||||
rtc_rv3028.initI2C(wire);
|
||||
rtc_rv3028.writeToRegister(0x35, 0x00);
|
||||
rtc_rv3028.writeToRegister(0x37, 0xB4); // Direct Switching Mode (DSM): when VDD < VBACKUP, switchover occurs from VDD to VBACKUP
|
||||
rtc_rv3028.set24HourMode(); // Set the device to use the 24hour format (default) instead of the 12 hour format
|
||||
rtc_rv3028.writeToRegister(0x35, 0x00);
|
||||
rtc_rv3028.writeToRegister(0x37, 0xB4); // Direct Switching Mode (DSM): when VDD < VBACKUP, switchover occurs from VDD to VBACKUP
|
||||
rtc_rv3028.set24HourMode(); // Set the device to use the 24hour format (default) instead of the 12 hour format
|
||||
rv3028_success = true;
|
||||
}
|
||||
if(i2c_probe(wire,PCF8563_ADDRESS)){
|
||||
|
||||
if (i2c_probe(wire, PCF8563_ADDRESS)) {
|
||||
rtc_8563_success = rtc_8563.begin(&wire);
|
||||
}
|
||||
|
||||
if (i2c_probe(wire, RX8130CE_ADDRESS)) {
|
||||
MESH_DEBUG_PRINTLN("RX8130CE: Found");
|
||||
rtc_8130.begin(&wire);
|
||||
rtc_8130_success = true;
|
||||
MESH_DEBUG_PRINTLN("RX8130CE: Initialized");
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t AutoDiscoverRTCClock::getCurrentTime() {
|
||||
if (ds3231_success) {
|
||||
return rtc_3231.now().unixtime();
|
||||
}
|
||||
|
||||
if (rv3028_success) {
|
||||
return DateTime(
|
||||
rtc_rv3028.getYear(),
|
||||
@@ -51,9 +68,16 @@ uint32_t AutoDiscoverRTCClock::getCurrentTime() {
|
||||
rtc_rv3028.getSecond()
|
||||
).unixtime();
|
||||
}
|
||||
if(rtc_8563_success){
|
||||
|
||||
if (rtc_8563_success) {
|
||||
return rtc_8563.now().unixtime();
|
||||
}
|
||||
|
||||
if (rtc_8130_success) {
|
||||
MESH_DEBUG_PRINTLN("RX8130CE: Reading time");
|
||||
return rtc_8130.now().unixtime();
|
||||
}
|
||||
|
||||
return _fallback->getCurrentTime();
|
||||
}
|
||||
|
||||
@@ -66,6 +90,9 @@ void AutoDiscoverRTCClock::setCurrentTime(uint32_t time) {
|
||||
rtc_rv3028.setTime(dt.year(), dt.month(), weekday, dt.day(), dt.hour(), dt.minute(), dt.second());
|
||||
} else if (rtc_8563_success) {
|
||||
rtc_8563.adjust(DateTime(time));
|
||||
} else if (rtc_8130_success) {
|
||||
MESH_DEBUG_PRINTLN("RX8130CE: Setting time");
|
||||
rtc_8130.adjust(DateTime(time));
|
||||
} else {
|
||||
_fallback->setCurrentTime(time);
|
||||
}
|
||||
|
||||
@@ -38,19 +38,19 @@ mesh::Packet* BaseChatMesh::createSelfAdvert(const char* name, double lat, doubl
|
||||
return createAdvert(self_id, app_data, app_data_len);
|
||||
}
|
||||
|
||||
void BaseChatMesh::sendAckTo(const ContactInfo& dest, uint32_t ack_hash) {
|
||||
void BaseChatMesh::sendAckTo(const ContactInfo& dest, const uint8_t* ack_hash, uint8_t ack_len) {
|
||||
if (dest.out_path_len == OUT_PATH_UNKNOWN) {
|
||||
mesh::Packet* ack = createAck(ack_hash);
|
||||
mesh::Packet* ack = createAck(ack_hash, ack_len);
|
||||
if (ack) sendFloodScoped(dest, ack, TXT_ACK_DELAY);
|
||||
} else {
|
||||
uint32_t d = TXT_ACK_DELAY;
|
||||
if (getExtraAckTransmitCount() > 0) {
|
||||
mesh::Packet* a1 = createMultiAck(ack_hash, 1);
|
||||
mesh::Packet* a1 = createMultiAck(ack_hash, ack_len, 1);
|
||||
if (a1) sendDirect(a1, dest.out_path, dest.out_path_len, d);
|
||||
d += 300;
|
||||
}
|
||||
|
||||
mesh::Packet* a2 = createAck(ack_hash);
|
||||
mesh::Packet* a2 = createAck(ack_hash, ack_len);
|
||||
if (a2) sendDirect(a2, dest.out_path, dest.out_path_len, d);
|
||||
}
|
||||
}
|
||||
@@ -67,18 +67,25 @@ void BaseChatMesh::bootstrapRTCfromContacts() {
|
||||
}
|
||||
}
|
||||
|
||||
ContactInfo* BaseChatMesh::allocateContactSlot() {
|
||||
ContactInfo* BaseChatMesh::allocateContactSlot(bool transient_only) {
|
||||
if (num_contacts < MAX_CONTACTS) {
|
||||
return &contacts[num_contacts++];
|
||||
} else if (shouldOverwriteWhenFull()) {
|
||||
} else if (transient_only || shouldOverwriteWhenFull()) {
|
||||
// Find oldest non-favourite contact by oldest lastmod timestamp
|
||||
int oldest_idx = -1;
|
||||
uint32_t oldest_lastmod = 0xFFFFFFFF;
|
||||
for (int i = 0; i < num_contacts; i++) {
|
||||
bool is_favourite = (contacts[i].flags & 0x01) != 0;
|
||||
if (!is_favourite && contacts[i].lastmod < oldest_lastmod) {
|
||||
oldest_lastmod = contacts[i].lastmod;
|
||||
oldest_idx = i;
|
||||
if (transient_only) {
|
||||
if (contacts[i].type == ADV_TYPE_NONE && contacts[i].lastmod < oldest_lastmod) {
|
||||
oldest_lastmod = contacts[i].lastmod;
|
||||
oldest_idx = i;
|
||||
}
|
||||
} else {
|
||||
bool is_favourite = (contacts[i].flags & 0x01) != 0;
|
||||
if (!is_favourite && contacts[i].lastmod < oldest_lastmod && contacts[i].type != ADV_TYPE_NONE) {
|
||||
oldest_lastmod = contacts[i].lastmod;
|
||||
oldest_idx = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (oldest_idx >= 0) {
|
||||
@@ -164,16 +171,17 @@ void BaseChatMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id,
|
||||
from->sync_since = 0;
|
||||
from->shared_secret_valid = false;
|
||||
}
|
||||
|
||||
// update
|
||||
putBlobByKey(id.pub_key, PUB_KEY_SIZE, temp_buf, plen);
|
||||
StrHelper::strncpy(from->name, parser.getName(), sizeof(from->name));
|
||||
from->type = parser.getType();
|
||||
if (parser.hasLatLon()) {
|
||||
from->gps_lat = parser.getIntLat();
|
||||
from->gps_lon = parser.getIntLon();
|
||||
}
|
||||
from->last_advert_timestamp = timestamp;
|
||||
from->lastmod = getRTCClock()->getCurrentTime();
|
||||
putBlobByKey(id.pub_key, PUB_KEY_SIZE, temp_buf, plen);
|
||||
StrHelper::strncpy(from->name, parser.getName(), sizeof(from->name));
|
||||
from->type = parser.getType();
|
||||
if (parser.hasLatLon()) {
|
||||
from->gps_lat = parser.getIntLat();
|
||||
from->gps_lon = parser.getIntLon();
|
||||
}
|
||||
from->last_advert_timestamp = timestamp;
|
||||
from->lastmod = getRTCClock()->getCurrentTime();
|
||||
|
||||
onDiscoveredContact(*from, is_new, packet->path_len, packet->path); // let UI know
|
||||
}
|
||||
@@ -218,16 +226,20 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
|
||||
from.lastmod = getRTCClock()->getCurrentTime(); // update last heard time
|
||||
onMessageRecv(from, packet, timestamp, (const char *) &data[5]); // let UI know
|
||||
|
||||
uint32_t ack_hash; // calc truncated hash of the message timestamp + text + sender pub_key, to prove to sender that we got it
|
||||
mesh::Utils::sha256((uint8_t *) &ack_hash, 4, data, 5 + strlen((char *)&data[5]), from.id.pub_key, PUB_KEY_SIZE);
|
||||
int text_len = strlen((char *)&data[5]);
|
||||
uint8_t ack_hash[6]; // calc truncated hash of the message timestamp + text + sender pub_key, to prove to sender that we got it
|
||||
mesh::Utils::sha256(ack_hash, 4, data, 5 + text_len, from.id.pub_key, PUB_KEY_SIZE);
|
||||
// NEW: append (potential) extended attempt byte (to make packethash unique)
|
||||
ack_hash[4] = data[5 + text_len + 1];
|
||||
getRNG()->random(&ack_hash[5], 1); // make 6th byte random
|
||||
|
||||
if (packet->isRouteFlood()) {
|
||||
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the ACK
|
||||
mesh::Packet* path = createPathReturn(from.id, secret, packet->path, packet->path_len,
|
||||
PAYLOAD_TYPE_ACK, (uint8_t *) &ack_hash, 4);
|
||||
PAYLOAD_TYPE_ACK, (uint8_t *) &ack_hash, 6);
|
||||
if (path) sendFloodScoped(from, path, TXT_ACK_DELAY);
|
||||
} else {
|
||||
sendAckTo(from, ack_hash);
|
||||
sendAckTo(from, ack_hash, 6);
|
||||
}
|
||||
} else if (flags == TXT_TYPE_CLI_DATA) {
|
||||
onCommandDataRecv(from, packet, timestamp, (const char *) &data[5]); // let UI know
|
||||
@@ -254,7 +266,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
|
||||
PAYLOAD_TYPE_ACK, (uint8_t *) &ack_hash, 4);
|
||||
if (path) sendFloodScoped(from, path, TXT_ACK_DELAY);
|
||||
} else {
|
||||
sendAckTo(from, ack_hash);
|
||||
sendAckTo(from, (uint8_t *) &ack_hash);
|
||||
}
|
||||
} else {
|
||||
MESH_DEBUG_PRINTLN("onPeerDataRecv: unsupported message type: %u", (uint32_t) flags);
|
||||
@@ -353,8 +365,18 @@ int BaseChatMesh::searchChannelsByHash(const uint8_t* hash, mesh::GroupChannel d
|
||||
#endif
|
||||
|
||||
void BaseChatMesh::onGroupDataRecv(mesh::Packet* packet, uint8_t type, const mesh::GroupChannel& channel, uint8_t* data, size_t len) {
|
||||
uint8_t txt_type = data[4];
|
||||
if (type == PAYLOAD_TYPE_GRP_TXT && len > 5 && (txt_type >> 2) == 0) { // 0 = plain text msg
|
||||
if (type == PAYLOAD_TYPE_GRP_TXT) {
|
||||
if (len < 5) {
|
||||
MESH_DEBUG_PRINTLN("onGroupDataRecv: dropping short group text payload len=%d", (uint32_t)len);
|
||||
return;
|
||||
}
|
||||
|
||||
uint8_t txt_type = data[4];
|
||||
if ((txt_type >> 2) != 0) {
|
||||
MESH_DEBUG_PRINTLN("onGroupDataRecv: dropping unsupported group text type=%d", (uint32_t)txt_type);
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t timestamp;
|
||||
memcpy(×tamp, data, 4);
|
||||
|
||||
@@ -363,6 +385,23 @@ void BaseChatMesh::onGroupDataRecv(mesh::Packet* packet, uint8_t type, const mes
|
||||
|
||||
// notify UI of this new message
|
||||
onChannelMessageRecv(channel, packet, timestamp, (const char *) &data[5]); // let UI know
|
||||
} else if (type == PAYLOAD_TYPE_GRP_DATA) {
|
||||
if (len < 3) {
|
||||
MESH_DEBUG_PRINTLN("onGroupDataRecv: dropping short group data payload len=%d", (uint32_t)len);
|
||||
return;
|
||||
}
|
||||
|
||||
uint16_t data_type = ((uint16_t)data[0]) | (((uint16_t)data[1]) << 8);
|
||||
uint8_t data_len = data[2];
|
||||
size_t available_len = len - 3;
|
||||
|
||||
if (data_len > available_len) {
|
||||
MESH_DEBUG_PRINTLN("onGroupDataRecv: dropping malformed group data type=%d len=%d available=%d",
|
||||
(uint32_t)data_type, (uint32_t)data_len, (uint32_t)available_len);
|
||||
return;
|
||||
}
|
||||
|
||||
onChannelDataRecv(channel, packet, data_type, &data[3], data_len);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -454,6 +493,37 @@ bool BaseChatMesh::sendGroupMessage(uint32_t timestamp, mesh::GroupChannel& chan
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BaseChatMesh::sendGroupData(mesh::GroupChannel& channel, uint8_t* path, uint8_t path_len, uint16_t data_type, const uint8_t* data, int data_len) {
|
||||
if (data_len < 0) {
|
||||
MESH_DEBUG_PRINTLN("sendGroupData: invalid negative data_len=%d", data_len);
|
||||
return false;
|
||||
}
|
||||
if (data_len > MAX_GROUP_DATA_LENGTH) {
|
||||
MESH_DEBUG_PRINTLN("sendGroupData: data_len=%d exceeds max=%d", data_len, MAX_GROUP_DATA_LENGTH);
|
||||
return false;
|
||||
}
|
||||
|
||||
uint8_t temp[3 + MAX_GROUP_DATA_LENGTH];
|
||||
temp[0] = (uint8_t)(data_type & 0xFF);
|
||||
temp[1] = (uint8_t)(data_type >> 8);
|
||||
temp[2] = (uint8_t)data_len;
|
||||
if (data_len > 0) memcpy(&temp[3], data, data_len);
|
||||
|
||||
auto pkt = createGroupDatagram(PAYLOAD_TYPE_GRP_DATA, channel, temp, 3 + data_len);
|
||||
if (pkt == NULL) {
|
||||
MESH_DEBUG_PRINTLN("sendGroupData: unable to create group datagram, data_len=%d", data_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (path_len == OUT_PATH_UNKNOWN) {
|
||||
sendFloodScoped(channel, pkt);
|
||||
} else {
|
||||
sendDirect(pkt, path, path_len);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool BaseChatMesh::shareContactZeroHop(const ContactInfo& contact) {
|
||||
int plen = getBlobByKey(contact.id.pub_key, PUB_KEY_SIZE, temp_buf); // retrieve last raw advert packet
|
||||
if (plen == 0) return false; // not found
|
||||
@@ -767,7 +837,7 @@ ContactInfo* BaseChatMesh::lookupContactByPubKey(const uint8_t* pub_key, int pre
|
||||
}
|
||||
|
||||
bool BaseChatMesh::addContact(const ContactInfo& contact) {
|
||||
ContactInfo* dest = allocateContactSlot();
|
||||
ContactInfo* dest = allocateContactSlot(contact.type == ADV_TYPE_NONE);
|
||||
if (dest) {
|
||||
*dest = contact;
|
||||
dest->shared_secret_valid = false; // mark shared_secret as needing calculation
|
||||
|
||||
@@ -37,6 +37,8 @@ public:
|
||||
#define MAX_CONTACTS 32
|
||||
#endif
|
||||
|
||||
#define MAX_ANON_CONTACTS 8
|
||||
|
||||
#ifndef MAX_CONNECTIONS
|
||||
#define MAX_CONNECTIONS 16
|
||||
#endif
|
||||
@@ -58,9 +60,9 @@ class BaseChatMesh : public mesh::Mesh {
|
||||
|
||||
friend class ContactsIterator;
|
||||
|
||||
ContactInfo contacts[MAX_CONTACTS];
|
||||
ContactInfo contacts[MAX_CONTACTS+MAX_ANON_CONTACTS];
|
||||
int num_contacts;
|
||||
int sort_array[MAX_CONTACTS];
|
||||
int sort_array[MAX_CONTACTS+MAX_ANON_CONTACTS];
|
||||
int matching_peer_indexes[MAX_SEARCH_RESULTS];
|
||||
unsigned long txt_send_timeout;
|
||||
#ifdef MAX_GROUP_CHANNELS
|
||||
@@ -72,7 +74,7 @@ class BaseChatMesh : public mesh::Mesh {
|
||||
ConnectionInfo connections[MAX_CONNECTIONS];
|
||||
|
||||
mesh::Packet* composeMsgPacket(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char *text, uint32_t& expected_ack);
|
||||
void sendAckTo(const ContactInfo& dest, uint32_t ack_hash);
|
||||
void sendAckTo(const ContactInfo& dest, const uint8_t* ack_hash, uint8_t ack_len=4);
|
||||
|
||||
protected:
|
||||
BaseChatMesh(mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::PacketManager& mgr, mesh::MeshTables& tables)
|
||||
@@ -91,7 +93,7 @@ protected:
|
||||
void bootstrapRTCfromContacts();
|
||||
void resetContacts() { num_contacts = 0; }
|
||||
void populateContactFromAdvert(ContactInfo& ci, const mesh::Identity& id, const AdvertDataParser& parser, uint32_t timestamp);
|
||||
ContactInfo* allocateContactSlot(); // helper to find slot for new contact
|
||||
ContactInfo* allocateContactSlot(bool transient_only=false); // helper to find slot for new contact
|
||||
|
||||
// 'UI' concepts, for sub-classes to implement
|
||||
virtual bool isAutoAddEnabled() const { return true; }
|
||||
@@ -111,6 +113,8 @@ protected:
|
||||
virtual uint32_t calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const = 0;
|
||||
virtual void onSendTimeout() = 0;
|
||||
virtual void onChannelMessageRecv(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t timestamp, const char *text) = 0;
|
||||
virtual void onChannelDataRecv(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint16_t data_type,
|
||||
const uint8_t* data, size_t data_len) {}
|
||||
virtual uint8_t onContactRequest(const ContactInfo& contact, uint32_t sender_timestamp, const uint8_t* data, uint8_t len, uint8_t* reply) = 0;
|
||||
virtual void onContactResponse(const ContactInfo& contact, const uint8_t* data, uint8_t len) = 0;
|
||||
virtual void handleReturnPathRetry(const ContactInfo& contact, const uint8_t* path, uint8_t path_len);
|
||||
@@ -148,6 +152,7 @@ public:
|
||||
int sendMessage(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char* text, uint32_t& expected_ack, uint32_t& est_timeout);
|
||||
int sendCommandData(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char* text, uint32_t& est_timeout);
|
||||
bool sendGroupMessage(uint32_t timestamp, mesh::GroupChannel& channel, const char* sender_name, const char* text, int text_len);
|
||||
bool sendGroupData(mesh::GroupChannel& channel, uint8_t* path, uint8_t path_len, uint16_t data_type, const uint8_t* data, int data_len);
|
||||
int sendLogin(const ContactInfo& recipient, const char* password, uint32_t& est_timeout);
|
||||
int sendAnonReq(const ContactInfo& recipient, const uint8_t* data, uint8_t len, uint32_t& tag, uint32_t& est_timeout);
|
||||
int sendRequest(const ContactInfo& recipient, uint8_t req_type, uint32_t& tag, uint32_t& est_timeout);
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
#define MAX_FRAME_SIZE 172
|
||||
#define MAX_FRAME_SIZE 176 // +4 for transport codes (region scoping)
|
||||
|
||||
class BaseSerialInterface {
|
||||
protected:
|
||||
|
||||
+681
-426
File diff suppressed because it is too large.
Load diff
+21
-3
@@ -4,6 +4,7 @@
|
||||
#include <helpers/IdentityStore.h>
|
||||
#include <helpers/SensorManager.h>
|
||||
#include <helpers/ClientACL.h>
|
||||
#include <helpers/RegionMap.h>
|
||||
|
||||
#if defined(WITH_RS232_BRIDGE) || defined(WITH_ESPNOW_BRIDGE)
|
||||
#define WITH_BRIDGE
|
||||
@@ -39,6 +40,8 @@ struct NodePrefs { // persisted to file
|
||||
uint8_t multi_acks;
|
||||
float bw;
|
||||
uint8_t flood_max;
|
||||
uint8_t flood_max_unscoped;
|
||||
uint8_t flood_max_advert;
|
||||
uint8_t interference_threshold;
|
||||
uint8_t agc_reset_interval; // secs / 4
|
||||
// Bridge settings
|
||||
@@ -88,6 +91,16 @@ public:
|
||||
virtual void clearStats() = 0;
|
||||
virtual void applyTempRadioParams(float freq, float bw, uint8_t sf, uint8_t cr, int timeout_mins) = 0;
|
||||
|
||||
virtual void startRegionsLoad() {
|
||||
// no op by default
|
||||
}
|
||||
virtual bool saveRegions() {
|
||||
return false;
|
||||
}
|
||||
virtual void onDefaultRegionChanged(const RegionEntry* r) {
|
||||
// no op by default
|
||||
}
|
||||
|
||||
virtual void setBridgeState(bool enable) {
|
||||
// no op by default
|
||||
};
|
||||
@@ -107,6 +120,7 @@ class CommonCLI {
|
||||
CommonCLICallbacks* _callbacks;
|
||||
mesh::MainBoard* _board;
|
||||
SensorManager* _sensors;
|
||||
RegionMap* _region_map;
|
||||
ClientACL* _acl;
|
||||
char tmp[PRV_KEY_SIZE*2 + 4];
|
||||
|
||||
@@ -114,12 +128,16 @@ class CommonCLI {
|
||||
void savePrefs();
|
||||
void loadPrefsInt(FILESYSTEM* _fs, const char* filename);
|
||||
|
||||
void handleRegionCmd(char* command, char* reply);
|
||||
void handleGetCmd(uint32_t sender_timestamp, char* command, char* reply);
|
||||
void handleSetCmd(uint32_t sender_timestamp, char* command, char* reply);
|
||||
|
||||
public:
|
||||
CommonCLI(mesh::MainBoard& board, mesh::RTCClock& rtc, SensorManager& sensors, ClientACL& acl, NodePrefs* prefs, CommonCLICallbacks* callbacks)
|
||||
: _board(&board), _rtc(&rtc), _sensors(&sensors), _acl(&acl), _prefs(prefs), _callbacks(callbacks) { }
|
||||
CommonCLI(mesh::MainBoard& board, mesh::RTCClock& rtc, SensorManager& sensors, RegionMap& region_map, ClientACL& acl, NodePrefs* prefs, CommonCLICallbacks* callbacks)
|
||||
: _board(&board), _rtc(&rtc), _sensors(&sensors), _region_map(®ion_map), _acl(&acl), _prefs(prefs), _callbacks(callbacks) { }
|
||||
|
||||
void loadPrefs(FILESYSTEM* _fs);
|
||||
void savePrefs(FILESYSTEM* _fs);
|
||||
void handleCommand(uint32_t sender_timestamp, const char* command, char* reply);
|
||||
void handleCommand(uint32_t sender_timestamp, char* command, char* reply);
|
||||
uint8_t buildAdvertData(uint8_t node_type, uint8_t* app_data);
|
||||
};
|
||||
+52
-23
@@ -3,22 +3,28 @@
|
||||
#include <MeshCore.h>
|
||||
#include <Arduino.h>
|
||||
|
||||
#ifndef USER_BTN_PRESSED
|
||||
#define USER_BTN_PRESSED LOW
|
||||
#endif
|
||||
|
||||
#if defined(ESP_PLATFORM)
|
||||
|
||||
#include <rom/rtc.h>
|
||||
#include <sys/time.h>
|
||||
#include <Wire.h>
|
||||
#include "driver/rtc_io.h"
|
||||
#include "soc/rtc.h"
|
||||
#include "esp_system.h"
|
||||
|
||||
class ESP32Board : public mesh::MainBoard {
|
||||
protected:
|
||||
uint8_t startup_reason;
|
||||
bool inhibit_sleep = false;
|
||||
static inline portMUX_TYPE sleepMux = portMUX_INITIALIZER_UNLOCKED;
|
||||
|
||||
public:
|
||||
void begin() {
|
||||
// for future use, sub-classes SHOULD call this from their begin()
|
||||
startup_reason = BD_STARTUP_NORMAL;
|
||||
startup_reason = BD_STARTUP_NORMAL;
|
||||
|
||||
#ifdef ESP32_CPU_FREQ
|
||||
setCpuFrequencyMhz(ESP32_CPU_FREQ);
|
||||
@@ -41,7 +47,7 @@ public:
|
||||
#endif
|
||||
#else
|
||||
Wire.begin();
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
// Temperature from ESP32 MCU
|
||||
@@ -56,25 +62,48 @@ public:
|
||||
return raw / 4;
|
||||
}
|
||||
|
||||
void enterLightSleep(uint32_t secs) {
|
||||
#if defined(CONFIG_IDF_TARGET_ESP32S3) && defined(P_LORA_DIO_1) // Supported ESP32 variants
|
||||
if (rtc_gpio_is_valid_gpio((gpio_num_t)P_LORA_DIO_1)) { // Only enter sleep mode if P_LORA_DIO_1 is RTC pin
|
||||
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
|
||||
esp_sleep_enable_ext1_wakeup((1L << P_LORA_DIO_1), ESP_EXT1_WAKEUP_ANY_HIGH); // To wake up when receiving a LoRa packet
|
||||
|
||||
if (secs > 0) {
|
||||
esp_sleep_enable_timer_wakeup(secs * 1000000); // To wake up every hour to do periodically jobs
|
||||
}
|
||||
|
||||
esp_light_sleep_start(); // CPU enters light sleep
|
||||
}
|
||||
#endif
|
||||
uint32_t getIRQGpio() override {
|
||||
return P_LORA_DIO_1; // default for SX1262
|
||||
}
|
||||
|
||||
void sleep(uint32_t secs) override {
|
||||
if (!inhibit_sleep) {
|
||||
enterLightSleep(secs); // To wake up after "secs" seconds or when receiving a LoRa packet
|
||||
// Skip if not allow to sleep
|
||||
if (inhibit_sleep) {
|
||||
delay(1); // Give MCU to OTA to run
|
||||
return;
|
||||
}
|
||||
|
||||
// Set GPIO wakeup
|
||||
gpio_num_t wakeupPin = (gpio_num_t)getIRQGpio();
|
||||
|
||||
// Configure timer wakeup
|
||||
if (secs > 0) {
|
||||
esp_sleep_enable_timer_wakeup(secs * 1000000ULL); // Wake up periodically to do scheduled jobs
|
||||
}
|
||||
|
||||
// Disable CPU interrupt servicing
|
||||
portENTER_CRITICAL(&sleepMux);
|
||||
|
||||
// Skip sleep if there is a LoRa packet
|
||||
if (gpio_get_level(wakeupPin) == HIGH) {
|
||||
portEXIT_CRITICAL(&sleepMux);
|
||||
delay(1);
|
||||
return;
|
||||
}
|
||||
|
||||
// Configure GPIO wakeup
|
||||
esp_sleep_enable_gpio_wakeup();
|
||||
gpio_wakeup_enable((gpio_num_t)wakeupPin, GPIO_INTR_HIGH_LEVEL); // Wake up when receiving a LoRa packet
|
||||
|
||||
// MCU enters light sleep
|
||||
esp_light_sleep_start();
|
||||
|
||||
// Avoid ISR flood during wakeup due to HIGH LEVEL interrupt
|
||||
gpio_wakeup_disable(wakeupPin);
|
||||
gpio_set_intr_type(wakeupPin, GPIO_INTR_POSEDGE);
|
||||
|
||||
// Enable CPU interrupt servicing
|
||||
portEXIT_CRITICAL(&sleepMux);
|
||||
}
|
||||
|
||||
uint8_t getStartupReason() const override { return startup_reason; }
|
||||
@@ -98,7 +127,7 @@ public:
|
||||
#endif
|
||||
|
||||
uint16_t getBattMilliVolts() override {
|
||||
#ifdef PIN_VBAT_READ
|
||||
#ifdef PIN_VBAT_READ
|
||||
analogReadResolution(12);
|
||||
|
||||
uint32_t raw = 0;
|
||||
@@ -137,16 +166,16 @@ public:
|
||||
// start with some date/time in the recent past
|
||||
struct timeval tv;
|
||||
tv.tv_sec = 1715770351; // 15 May 2024, 8:50pm
|
||||
tv.tv_usec = 0;
|
||||
settimeofday(&tv, NULL);
|
||||
}
|
||||
tv.tv_usec = 0;
|
||||
settimeofday(&tv, NULL);
|
||||
}
|
||||
}
|
||||
uint32_t getCurrentTime() override {
|
||||
time_t _now;
|
||||
time(&_now);
|
||||
return _now;
|
||||
}
|
||||
void setCurrentTime(uint32_t time) override {
|
||||
void setCurrentTime(uint32_t time) override {
|
||||
struct timeval tv;
|
||||
tv.tv_sec = time;
|
||||
tv.tv_usec = 0;
|
||||
|
||||
+14
-14
@@ -66,20 +66,6 @@ void NRF52Board::initPowerMgr() {
|
||||
}
|
||||
}
|
||||
|
||||
bool NRF52Board::isExternalPowered() {
|
||||
// Check if SoftDevice is enabled before using its API
|
||||
uint8_t sd_enabled = 0;
|
||||
sd_softdevice_is_enabled(&sd_enabled);
|
||||
|
||||
if (sd_enabled) {
|
||||
uint32_t usb_status;
|
||||
sd_power_usbregstatus_get(&usb_status);
|
||||
return (usb_status & POWER_USBREGSTATUS_VBUSDETECT_Msk) != 0;
|
||||
} else {
|
||||
return (NRF_POWER->USBREGSTATUS & POWER_USBREGSTATUS_VBUSDETECT_Msk) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
const char* NRF52Board::getResetReasonString(uint32_t reason) {
|
||||
if (reason & POWER_RESETREAS_RESETPIN_Msk) return "Reset Pin";
|
||||
if (reason & POWER_RESETREAS_DOG_Msk) return "Watchdog";
|
||||
@@ -251,6 +237,20 @@ void NRF52BoardDCDC::begin() {
|
||||
}
|
||||
}
|
||||
|
||||
bool NRF52Board::isExternalPowered() {
|
||||
// Check if SoftDevice is enabled before using its API
|
||||
uint8_t sd_enabled = 0;
|
||||
sd_softdevice_is_enabled(&sd_enabled);
|
||||
|
||||
if (sd_enabled) {
|
||||
uint32_t usb_status;
|
||||
sd_power_usbregstatus_get(&usb_status);
|
||||
return (usb_status & POWER_USBREGSTATUS_VBUSDETECT_Msk) != 0;
|
||||
} else {
|
||||
return (NRF_POWER->USBREGSTATUS & POWER_USBREGSTATUS_VBUSDETECT_Msk) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
void NRF52Board::sleep(uint32_t secs) {
|
||||
// Clear FPU interrupt flags to avoid insomnia
|
||||
// see errata 87 for details https://docs.nordicsemi.com/bundle/errata_nRF52840_Rev3/page/ERR/nRF52840/Rev3/latest/anomaly_840_87.html
|
||||
|
||||
@@ -53,9 +53,9 @@ public:
|
||||
virtual bool getBootloaderVersion(char* version, size_t max_len) override;
|
||||
virtual bool startOTAUpdate(const char *id, char reply[]) override;
|
||||
virtual void sleep(uint32_t secs) override;
|
||||
bool isExternalPowered() override;
|
||||
|
||||
#ifdef NRF52_POWER_MANAGEMENT
|
||||
bool isExternalPowered() override;
|
||||
uint16_t getBootVoltage() override { return boot_voltage_mv; }
|
||||
virtual uint32_t getResetReason() const override { return reset_reason; }
|
||||
uint8_t getShutdownReason() const override { return shutdown_reason; }
|
||||
@@ -67,7 +67,7 @@ public:
|
||||
/*
|
||||
* The NRF52 has an internal DC/DC regulator that allows increased efficiency
|
||||
* compared to the LDO regulator. For being able to use it, the module/board
|
||||
* needs to have the required inductors and and capacitors populated. If the
|
||||
* needs to have the required inductors and capacitors populated. If the
|
||||
* hardware requirements are met, this subclass can be used to enable the DC/DC
|
||||
* regulator.
|
||||
*/
|
||||
|
||||
@@ -0,0 +1,197 @@
|
||||
#include "RTC_RX8130CE.h"
|
||||
#include "RTClib.h"
|
||||
|
||||
|
||||
bool RTC_RX8130CE::stop(bool stop) {
|
||||
write_register(0x1E, stop ? 0x040 : 0x00);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RTC_RX8130CE::begin(TwoWire *wire) {
|
||||
if (i2c_dev) {
|
||||
delete i2c_dev;
|
||||
}
|
||||
|
||||
i2c_dev = new Adafruit_I2CDevice(this->_addr, wire);
|
||||
if (!i2c_dev->begin()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Digital offset register:
|
||||
* [7] DET: 0 -> disabled
|
||||
* [6:0] L7-L1: 0 -> no offset
|
||||
*/
|
||||
write_register(0x30, 0x00);
|
||||
|
||||
/*
|
||||
* Extension Register register:
|
||||
* [7:6] FSEL: 0 -> 0
|
||||
* [5] USEL: 0 -> 0
|
||||
* [4] TE: 0 ->
|
||||
* [3] WADA: 0 -> 0
|
||||
* [2-0] TSEL: 0 -> 0
|
||||
*/
|
||||
write_register(0x1C, 0x00);
|
||||
|
||||
/*
|
||||
* Flag Register register:
|
||||
* [7] VBLF: 0 -> 0
|
||||
* [6] 0: 0 ->
|
||||
* [5] UF: 0 ->
|
||||
* [4] TF: 0 ->
|
||||
* [3] AF: 0 -> 0
|
||||
* [2] RSF: 0 -> 0
|
||||
* [1] VLF: 0 -> 0
|
||||
* [0] VBFF: 0 -> 0
|
||||
*/
|
||||
write_register(0x1D, 0x00);
|
||||
|
||||
/*
|
||||
* Control Register0 register:
|
||||
* [7] TEST: 0 -> 0
|
||||
* [6] STOP: 0 ->
|
||||
* [5] UIE: 0 ->
|
||||
* [4] TIE: 0 ->
|
||||
* [3] AIE: 0 -> 0
|
||||
* [2] TSTP: 0 -> 0
|
||||
* [1] TBKON: 0 -> 0
|
||||
* [0] TBKE: 0 -> 0
|
||||
*/
|
||||
write_register(0x1E, 0x00);
|
||||
|
||||
/*
|
||||
* Control Register1 register:
|
||||
* [7-6] SMPTSEL: 0 -> 0
|
||||
* [5] CHGEN: 0 ->
|
||||
* [4] INIEN: 0 ->
|
||||
* [3] 0: 0 ->
|
||||
* [2] RSVSEL: 0 -> 0
|
||||
* [1-0] BFVSEL: 0 -> 0
|
||||
*/
|
||||
write_register(0x1F, 0x00);
|
||||
|
||||
this->stop(false); // clear STOP bit
|
||||
|
||||
/*
|
||||
* Function register:
|
||||
* [7] 100TH: 0 -> disabled
|
||||
* [6:5] Periodic interrupt: 0 -> no periodic interrupt
|
||||
* [4] RTCM: 0 -> real-time clock mode
|
||||
* [3] STOPM: 0 -> RTC stop is controlled by STOP bit only
|
||||
* [2:0] Clock output frequency: 000 (Default value)
|
||||
*/
|
||||
write_register(0x28, 0x00);
|
||||
|
||||
// Battery switch register
|
||||
write_register(0x26, 0x00); // enable battery switch feature
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RTC_RX8130CE::setTime(struct tm *t) {
|
||||
uint8_t buf[8];
|
||||
buf[0] = 0x10;
|
||||
buf[1] = bin2bcd(t->tm_sec) & 0x7F;
|
||||
buf[2] = bin2bcd(t->tm_min) & 0x7F;
|
||||
buf[3] = bin2bcd(t->tm_hour) & 0x3F;
|
||||
buf[4] = bin2bcd(t->tm_wday) & 0x07;
|
||||
buf[5] = bin2bcd(t->tm_mday) & 0x3F;
|
||||
buf[6] = bin2bcd(t->tm_mon + 1) & 0x1F;
|
||||
buf[7] = bin2bcd((t->tm_year - 100));
|
||||
|
||||
this->stop(true);
|
||||
i2c_dev->write(buf, sizeof(buf));
|
||||
this->stop(false);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void RTC_RX8130CE::adjust(DateTime dt) {
|
||||
struct tm *atv;
|
||||
time_t utime;
|
||||
|
||||
utime = (time_t)dt.unixtime();
|
||||
atv = gmtime(&utime);
|
||||
|
||||
this->setTime(atv);
|
||||
}
|
||||
|
||||
DateTime RTC_RX8130CE::now() {
|
||||
struct tm atv;
|
||||
this->getTime(&atv);
|
||||
|
||||
return DateTime((uint32_t)mktime(&atv));
|
||||
}
|
||||
|
||||
uint32_t RTC_RX8130CE::unixtime() {
|
||||
struct tm atv;
|
||||
this->getTime(&atv);
|
||||
|
||||
return (uint32_t)mktime(&atv);
|
||||
}
|
||||
|
||||
bool RTC_RX8130CE::getTime(struct tm *t) {
|
||||
uint8_t buff[7];
|
||||
|
||||
buff[0] = 0x10;
|
||||
|
||||
i2c_dev->write_then_read(buff, 1, buff, 7);
|
||||
|
||||
t->tm_sec = bcd2bin(buff[0] & 0x7F);
|
||||
t->tm_min = bcd2bin(buff[1] & 0x7F);
|
||||
t->tm_hour = bcd2bin(buff[2] & 0x3F);
|
||||
t->tm_wday = bcd2bin(buff[3] & 0x07);
|
||||
t->tm_mday = bcd2bin(buff[4] & 0x3F);
|
||||
t->tm_mon = bcd2bin(buff[5] & 0x1F) - 1;
|
||||
t->tm_year = bcd2bin(buff[6]) + 100;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RTC_RX8130CE::writeRAM(uint8_t address, uint8_t value) {
|
||||
return this->writeRAM(address, &value, 1);
|
||||
}
|
||||
|
||||
size_t RTC_RX8130CE::writeRAM(uint8_t address, uint8_t *value, size_t len) {
|
||||
uint8_t buf[len + 1];
|
||||
|
||||
if (address > 3) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((address + len) > 3) {
|
||||
len = 3 - address;
|
||||
}
|
||||
|
||||
buf[0] = 0x20 + address;
|
||||
|
||||
for (int i = 1; i <= len + 1; i++) {
|
||||
buf[i] = value[i - 1];
|
||||
}
|
||||
|
||||
i2c_dev->write(buf, len + 1);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
bool RTC_RX8130CE::readRAM(uint8_t address, uint8_t *value, size_t len) {
|
||||
uint8_t real_address = 0x20 + address;
|
||||
|
||||
if (address > 3) { // Oversize of 64-bytes RAM
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((address + len) > 3) { // Data size over RAM size
|
||||
len = 3 - address;
|
||||
}
|
||||
|
||||
i2c_dev->write_then_read(&real_address, 1, value, len);
|
||||
return true;
|
||||
}
|
||||
|
||||
uint8_t RTC_RX8130CE::readRAM(uint8_t address) {
|
||||
uint8_t value = 0xFF;
|
||||
this->readRAM(address, &value, 1);
|
||||
return value;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#ifndef __RTC_RX8130CE_H__
|
||||
#define __RTC_RX8130CE_H__
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <Wire.h>
|
||||
#include <time.h>
|
||||
#include "RTClib.h"
|
||||
|
||||
class RTC_RX8130CE : RTC_I2C {
|
||||
private:
|
||||
const uint8_t _addr = 0x32;
|
||||
|
||||
bool stop(bool stop);
|
||||
|
||||
protected:
|
||||
|
||||
public:
|
||||
bool begin(TwoWire *wire);
|
||||
bool setTime(struct tm *t);
|
||||
bool getTime(struct tm *t);
|
||||
void adjust(DateTime t);
|
||||
|
||||
DateTime now();
|
||||
uint32_t unixtime();
|
||||
|
||||
bool writeRAM(uint8_t address, uint8_t value);
|
||||
size_t writeRAM(uint8_t address, uint8_t *value, size_t len);
|
||||
bool readRAM(uint8_t address, uint8_t *value, size_t len);
|
||||
uint8_t readRAM(uint8_t address);
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
+34
-17
@@ -42,7 +42,8 @@ private:
|
||||
|
||||
|
||||
RegionMap::RegionMap(TransportKeyStore& store) : _store(&store) {
|
||||
next_id = 1; num_regions = 0; home_id = 0;
|
||||
next_id = 1; num_regions = 0;
|
||||
default_id = home_id = 0;
|
||||
wildcard.id = wildcard.parent = 0;
|
||||
wildcard.flags = 0; // default behaviour, allow flood and direct
|
||||
strcpy(wildcard.name, "*");
|
||||
@@ -79,9 +80,11 @@ bool RegionMap::load(FILESYSTEM* _fs, const char* path) {
|
||||
if (file) {
|
||||
uint8_t pad[128];
|
||||
|
||||
num_regions = 0; next_id = 1; home_id = 0;
|
||||
num_regions = 0; next_id = 1;
|
||||
default_id = home_id = 0;
|
||||
|
||||
bool success = file.read(pad, 5) == 5; // reserved header
|
||||
bool success = file.read(pad, 3) == 3; // reserved header
|
||||
success = success && file.read((uint8_t *) &default_id, sizeof(default_id)) == sizeof(default_id);
|
||||
success = success && file.read((uint8_t *) &home_id, sizeof(home_id)) == sizeof(home_id);
|
||||
success = success && file.read((uint8_t *) &wildcard.flags, sizeof(wildcard.flags)) == sizeof(wildcard.flags);
|
||||
success = success && file.read((uint8_t *) &next_id, sizeof(next_id)) == sizeof(next_id);
|
||||
@@ -117,7 +120,8 @@ bool RegionMap::save(FILESYSTEM* _fs, const char* path) {
|
||||
uint8_t pad[128];
|
||||
memset(pad, 0, sizeof(pad));
|
||||
|
||||
bool success = file.write(pad, 5) == 5; // reserved header
|
||||
bool success = file.write(pad, 3) == 3; // reserved header
|
||||
success = success && file.write((uint8_t *) &default_id, sizeof(default_id)) == sizeof(default_id);
|
||||
success = success && file.write((uint8_t *) &home_id, sizeof(home_id)) == sizeof(home_id);
|
||||
success = success && file.write((uint8_t *) &wildcard.flags, sizeof(wildcard.flags)) == sizeof(wildcard.flags);
|
||||
success = success && file.write((uint8_t *) &next_id, sizeof(next_id)) == sizeof(next_id);
|
||||
@@ -164,24 +168,29 @@ RegionEntry* RegionMap::putRegion(const char* name, uint16_t parent_id, uint16_t
|
||||
return region;
|
||||
}
|
||||
|
||||
int RegionMap::getTransportKeysFor(const RegionEntry& src, TransportKey dest[], int max_num) {
|
||||
int num;
|
||||
if (src.name[0] == '$') { // private region
|
||||
num = _store->loadKeysFor(src.id, dest, max_num);
|
||||
} else if (src.name[0] == '#') { // auto hashtag region
|
||||
_store->getAutoKeyFor(src.id, src.name, dest[0]);
|
||||
num = 1;
|
||||
} else { // new: implicit auto hashtag region
|
||||
char tmp[sizeof(src.name)+1];
|
||||
tmp[0] = '#';
|
||||
strcpy(&tmp[1], src.name);
|
||||
_store->getAutoKeyFor(src.id, tmp, dest[0]);
|
||||
num = 1;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
RegionEntry* RegionMap::findMatch(mesh::Packet* packet, uint8_t mask) {
|
||||
for (int i = 0; i < num_regions; i++) {
|
||||
auto region = ®ions[i];
|
||||
if ((region->flags & mask) == 0) { // does region allow this? (per 'mask' param)
|
||||
TransportKey keys[4];
|
||||
int num;
|
||||
if (region->name[0] == '$') { // private region
|
||||
num = _store->loadKeysFor(region->id, keys, 4);
|
||||
} else if (region->name[0] == '#') { // auto hashtag region
|
||||
_store->getAutoKeyFor(region->id, region->name, keys[0]);
|
||||
num = 1;
|
||||
} else { // new: implicit auto hashtag region
|
||||
char tmp[sizeof(region->name)];
|
||||
tmp[0] = '#';
|
||||
strcpy(&tmp[1], region->name);
|
||||
_store->getAutoKeyFor(region->id, tmp, keys[0]);
|
||||
num = 1;
|
||||
}
|
||||
int num = getTransportKeysFor(*region, keys, 4);
|
||||
for (int j = 0; j < num; j++) {
|
||||
uint16_t code = keys[j].calcTransportCode(packet);
|
||||
if (packet->transport_codes[0] == code) { // a match!!
|
||||
@@ -237,6 +246,14 @@ void RegionMap::setHomeRegion(const RegionEntry* home) {
|
||||
home_id = home ? home->id : 0;
|
||||
}
|
||||
|
||||
RegionEntry* RegionMap::getDefaultRegion() {
|
||||
return default_id == 0 ? NULL : findById(default_id);
|
||||
}
|
||||
|
||||
void RegionMap::setDefaultRegion(const RegionEntry* def) {
|
||||
default_id = def ? def->id : 0;
|
||||
}
|
||||
|
||||
bool RegionMap::removeRegion(const RegionEntry& region) {
|
||||
if (region.id == 0) return false; // failed (cannot remove the wildcard Region)
|
||||
|
||||
|
||||
@@ -16,11 +16,13 @@ struct RegionEntry {
|
||||
uint16_t parent;
|
||||
uint8_t flags;
|
||||
char name[31];
|
||||
|
||||
bool isWildcard() const { return id == 0; }
|
||||
};
|
||||
|
||||
class RegionMap {
|
||||
TransportKeyStore* _store;
|
||||
uint16_t next_id, home_id;
|
||||
uint16_t next_id, home_id, default_id;
|
||||
uint16_t num_regions;
|
||||
RegionEntry regions[MAX_REGION_ENTRIES];
|
||||
RegionEntry wildcard;
|
||||
@@ -43,6 +45,8 @@ public:
|
||||
RegionEntry* findById(uint16_t id);
|
||||
RegionEntry* getHomeRegion(); // NOTE: can be NULL
|
||||
void setHomeRegion(const RegionEntry* home);
|
||||
RegionEntry* getDefaultRegion(); // NOTE: can be NULL
|
||||
void setDefaultRegion(const RegionEntry* def);
|
||||
bool removeRegion(const RegionEntry& region);
|
||||
bool clear();
|
||||
void resetFrom(const RegionMap& src) { num_regions = 0; next_id = src.next_id; }
|
||||
@@ -50,6 +54,7 @@ public:
|
||||
const RegionEntry* getByIdx(int i) const { return ®ions[i]; }
|
||||
const RegionEntry* getRoot() const { return &wildcard; }
|
||||
int exportNamesTo(char *dest, int max_len, uint8_t mask, bool invert = false);
|
||||
int getTransportKeysFor(const RegionEntry& src, TransportKey dest[], int max_num);
|
||||
|
||||
void exportTo(Stream& out) const;
|
||||
size_t exportTo(char *dest, size_t max_len) const;
|
||||
|
||||
@@ -6,22 +6,17 @@
|
||||
#include <FS.h>
|
||||
#endif
|
||||
|
||||
#define MAX_PACKET_HASHES 128
|
||||
#define MAX_PACKET_ACKS 64
|
||||
#define MAX_PACKET_HASHES (128+32)
|
||||
|
||||
class SimpleMeshTables : public mesh::MeshTables {
|
||||
uint8_t _hashes[MAX_PACKET_HASHES*MAX_HASH_SIZE];
|
||||
int _next_idx;
|
||||
uint32_t _acks[MAX_PACKET_ACKS];
|
||||
int _next_ack_idx;
|
||||
uint32_t _direct_dups, _flood_dups;
|
||||
|
||||
public:
|
||||
SimpleMeshTables() {
|
||||
memset(_hashes, 0, sizeof(_hashes));
|
||||
_next_idx = 0;
|
||||
memset(_acks, 0, sizeof(_acks));
|
||||
_next_ack_idx = 0;
|
||||
_direct_dups = _flood_dups = 0;
|
||||
}
|
||||
|
||||
@@ -29,37 +24,14 @@ public:
|
||||
void restoreFrom(File f) {
|
||||
f.read(_hashes, sizeof(_hashes));
|
||||
f.read((uint8_t *) &_next_idx, sizeof(_next_idx));
|
||||
f.read((uint8_t *) &_acks[0], sizeof(_acks));
|
||||
f.read((uint8_t *) &_next_ack_idx, sizeof(_next_ack_idx));
|
||||
}
|
||||
void saveTo(File f) {
|
||||
f.write(_hashes, sizeof(_hashes));
|
||||
f.write((const uint8_t *) &_next_idx, sizeof(_next_idx));
|
||||
f.write((const uint8_t *) &_acks[0], sizeof(_acks));
|
||||
f.write((const uint8_t *) &_next_ack_idx, sizeof(_next_ack_idx));
|
||||
}
|
||||
#endif
|
||||
|
||||
bool hasSeen(const mesh::Packet* packet) override {
|
||||
if (packet->getPayloadType() == PAYLOAD_TYPE_ACK) {
|
||||
uint32_t ack;
|
||||
memcpy(&ack, packet->payload, 4);
|
||||
for (int i = 0; i < MAX_PACKET_ACKS; i++) {
|
||||
if (ack == _acks[i]) {
|
||||
if (packet->isRouteDirect()) {
|
||||
_direct_dups++; // keep some stats
|
||||
} else {
|
||||
_flood_dups++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
_acks[_next_ack_idx] = ack;
|
||||
_next_ack_idx = (_next_ack_idx + 1) % MAX_PACKET_ACKS; // cyclic table
|
||||
return false;
|
||||
}
|
||||
|
||||
uint8_t hash[MAX_HASH_SIZE];
|
||||
packet->calculatePacketHash(hash);
|
||||
|
||||
@@ -81,25 +53,14 @@ public:
|
||||
}
|
||||
|
||||
void clear(const mesh::Packet* packet) override {
|
||||
if (packet->getPayloadType() == PAYLOAD_TYPE_ACK) {
|
||||
uint32_t ack;
|
||||
memcpy(&ack, packet->payload, 4);
|
||||
for (int i = 0; i < MAX_PACKET_ACKS; i++) {
|
||||
if (ack == _acks[i]) {
|
||||
_acks[i] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
uint8_t hash[MAX_HASH_SIZE];
|
||||
packet->calculatePacketHash(hash);
|
||||
uint8_t hash[MAX_HASH_SIZE];
|
||||
packet->calculatePacketHash(hash);
|
||||
|
||||
uint8_t* sp = _hashes;
|
||||
for (int i = 0; i < MAX_PACKET_HASHES; i++, sp += MAX_HASH_SIZE) {
|
||||
if (memcmp(hash, sp, MAX_HASH_SIZE) == 0) {
|
||||
memset(sp, 0, MAX_HASH_SIZE);
|
||||
break;
|
||||
}
|
||||
uint8_t* sp = _hashes;
|
||||
for (int i = 0; i < MAX_PACKET_HASHES; i++, sp += MAX_HASH_SIZE) {
|
||||
if (memcmp(hash, sp, MAX_HASH_SIZE) == 0) {
|
||||
memset(sp, 0, MAX_HASH_SIZE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,9 +3,11 @@
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#define TXT_TYPE_PLAIN 0 // a plain text message
|
||||
#define TXT_TYPE_CLI_DATA 1 // a CLI command
|
||||
#define TXT_TYPE_SIGNED_PLAIN 2 // plain text, signed by sender
|
||||
#define TXT_TYPE_PLAIN 0 // a plain text message
|
||||
#define TXT_TYPE_CLI_DATA 1 // a CLI command
|
||||
#define TXT_TYPE_SIGNED_PLAIN 2 // plain text, signed by sender
|
||||
#define DATA_TYPE_RESERVED 0x0000 // reserved for future use
|
||||
#define DATA_TYPE_DEV 0xFFFF // developer namespace for experimenting with group/channel datagrams and building apps
|
||||
|
||||
class StrHelper {
|
||||
public:
|
||||
|
||||
@@ -54,6 +54,10 @@ void ESPNOWRadio::init() {
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t ESPNOWRadio::getRngSeed() {
|
||||
return millis() + intID(); // TODO: where to get some entropy?
|
||||
}
|
||||
|
||||
void ESPNOWRadio::setTxPower(uint8_t dbm) {
|
||||
esp_wifi_set_max_tx_power(dbm * 4);
|
||||
}
|
||||
|
||||
@@ -4,10 +4,17 @@
|
||||
|
||||
class ESPNOWRadio : public mesh::Radio {
|
||||
protected:
|
||||
uint32_t n_recv, n_sent;
|
||||
uint32_t n_recv, n_sent, n_recv_errors;
|
||||
|
||||
public:
|
||||
ESPNOWRadio() { n_recv = n_sent = 0; }
|
||||
ESPNOWRadio() { n_recv = n_sent = n_recv_errors = 0; }
|
||||
|
||||
uint32_t getRngSeed();
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) {
|
||||
// no-op
|
||||
}
|
||||
void powerOff() { /* no-op */ }
|
||||
|
||||
void init();
|
||||
int recvRaw(uint8_t* bytes, int sz) override;
|
||||
@@ -19,12 +26,21 @@ public:
|
||||
|
||||
uint32_t getPacketsRecv() const { return n_recv; }
|
||||
uint32_t getPacketsSent() const { return n_sent; }
|
||||
void resetStats() { n_recv = n_sent = 0; }
|
||||
uint32_t getPacketsRecvErrors() const { return n_recv_errors; }
|
||||
void resetStats() { n_recv = n_sent = n_recv_errors = 0; }
|
||||
|
||||
virtual float getLastRSSI() const override;
|
||||
virtual float getLastSNR() const override;
|
||||
|
||||
float packetScore(float snr, int packet_len) override { return 0; }
|
||||
|
||||
/**
|
||||
* These two functions do nothing for ESP-NOW, but are needed for the
|
||||
* Radio interface.
|
||||
*/
|
||||
virtual void setRxBoostedGainMode(bool) { }
|
||||
virtual bool getRxBoostedGainMode() const { return false; }
|
||||
|
||||
uint32_t intID();
|
||||
void setTxPower(uint8_t dbm);
|
||||
};
|
||||
|
||||
@@ -59,13 +59,13 @@
|
||||
// uint32_t P_LORA_BUSY = 0; //shared, so define at run
|
||||
// uint32_t P_LORA_DIO_2 = 0; //SX1276 only, so define at run
|
||||
|
||||
#define P_LORA_DIO_0 26
|
||||
#define P_LORA_DIO_1 33
|
||||
#define P_LORA_NSS 18
|
||||
#define P_LORA_RESET 23
|
||||
#define P_LORA_SCLK 5
|
||||
#define P_LORA_MISO 19
|
||||
#define P_LORA_MOSI 27
|
||||
// #define P_LORA_DIO_0 26
|
||||
// #define P_LORA_DIO_1 33
|
||||
// #define P_LORA_NSS 18
|
||||
// #define P_LORA_RESET 23
|
||||
// #define P_LORA_SCLK 5
|
||||
// #define P_LORA_MISO 19
|
||||
// #define P_LORA_MOSI 27
|
||||
|
||||
// #define PIN_GPS_RX 34
|
||||
// #define PIN_GPS_TX 12
|
||||
|
||||
@@ -181,6 +181,13 @@ void SerialBLEInterface::begin(const char* prefix, char* name, uint32_t pin_code
|
||||
bleuart.begin();
|
||||
bleuart.setRxCallback(onBleUartRX);
|
||||
|
||||
|
||||
|
||||
// Register DFU on the main BLE stack so paired clients can discover it
|
||||
// without switching the device into a separate OTA-only BLE mode first.
|
||||
bledfu.setPermission(SECMODE_ENC_WITH_MITM, SECMODE_ENC_WITH_MITM);
|
||||
bledfu.begin();
|
||||
|
||||
Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
|
||||
Bluefruit.Advertising.addTxPower();
|
||||
Bluefruit.Advertising.addService(bleuart);
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
#endif
|
||||
|
||||
class SerialBLEInterface : public BaseSerialInterface {
|
||||
BLEDfu bledfu;
|
||||
BLEUart bleuart;
|
||||
bool _isEnabled;
|
||||
bool _isDeviceConnected;
|
||||
|
||||
@@ -7,6 +7,15 @@
|
||||
class CustomLLCC68Wrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomLLCC68Wrapper(CustomLLCC68& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomLLCC68 *)_radio)->setFrequency(freq);
|
||||
((CustomLLCC68 *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomLLCC68 *)_radio)->setBandwidth(bw);
|
||||
((CustomLLCC68 *)_radio)->setCodingRate(cr);
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLLCC68 *)_radio)->isReceiving();
|
||||
}
|
||||
@@ -20,6 +29,7 @@ public:
|
||||
int sf = ((CustomLLCC68 *)_radio)->spreadingFactor;
|
||||
return packetScoreInt(snr, sf, packet_len);
|
||||
}
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomLLCC68 *)_radio)->spreadingFactor; }
|
||||
|
||||
void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
|
||||
|
||||
|
||||
@@ -36,4 +36,6 @@ class CustomLR1110 : public LR1110 {
|
||||
bool detected = ((irq & RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID) || (irq & RADIOLIB_LR11X0_IRQ_PREAMBLE_DETECTED));
|
||||
return detected;
|
||||
}
|
||||
|
||||
uint8_t getSpreadingFactor() const { return spreadingFactor; }
|
||||
};
|
||||
@@ -7,6 +7,15 @@
|
||||
class CustomLR1110Wrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomLR1110Wrapper(CustomLR1110& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomLR1110 *)_radio)->setFrequency(freq);
|
||||
((CustomLR1110 *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomLR1110 *)_radio)->setBandwidth(bw);
|
||||
((CustomLR1110 *)_radio)->setCodingRate(cr);
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
void doResetAGC() override { lr11x0ResetAGC((LR11x0 *)_radio, ((CustomLR1110 *)_radio)->getFreqMHz()); }
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomLR1110 *)_radio)->isReceiving();
|
||||
@@ -19,12 +28,14 @@ public:
|
||||
|
||||
void onSendFinished() override {
|
||||
RadioLibWrapper::onSendFinished();
|
||||
_radio->setPreambleLength(16); // overcomes weird issues with small and big pkts
|
||||
_radio->setPreambleLength(preambleLengthForSF(getSpreadingFactor())); // overcomes weird issues with small and big pkts
|
||||
}
|
||||
|
||||
float getLastRSSI() const override { return ((CustomLR1110 *)_radio)->getRSSI(); }
|
||||
float getLastSNR() const override { return ((CustomLR1110 *)_radio)->getSNR(); }
|
||||
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomLR1110 *)_radio)->getSpreadingFactor(); }
|
||||
|
||||
void setRxBoostedGainMode(bool en) override {
|
||||
((CustomLR1110 *)_radio)->setRxBoostedGainMode(en);
|
||||
}
|
||||
|
||||
@@ -8,6 +8,15 @@
|
||||
class CustomSTM32WLxWrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomSTM32WLxWrapper(CustomSTM32WLx& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomSTM32WLx *)_radio)->setFrequency(freq);
|
||||
((CustomSTM32WLx *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomSTM32WLx *)_radio)->setBandwidth(bw);
|
||||
((CustomSTM32WLx *)_radio)->setCodingRate(cr);
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSTM32WLx *)_radio)->isReceiving();
|
||||
}
|
||||
@@ -21,6 +30,7 @@ public:
|
||||
int sf = ((CustomSTM32WLx *)_radio)->spreadingFactor;
|
||||
return packetScoreInt(snr, sf, packet_len);
|
||||
}
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomSTM32WLx *)_radio)->spreadingFactor; }
|
||||
|
||||
void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
|
||||
};
|
||||
@@ -11,6 +11,15 @@
|
||||
class CustomSX1262Wrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomSX1262Wrapper(CustomSX1262& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomSX1262 *)_radio)->setFrequency(freq);
|
||||
((CustomSX1262 *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomSX1262 *)_radio)->setBandwidth(bw);
|
||||
((CustomSX1262 *)_radio)->setCodingRate(cr);
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1262 *)_radio)->isReceiving();
|
||||
}
|
||||
@@ -24,6 +33,7 @@ public:
|
||||
int sf = ((CustomSX1262 *)_radio)->spreadingFactor;
|
||||
return packetScoreInt(snr, sf, packet_len);
|
||||
}
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomSX1262 *)_radio)->spreadingFactor; }
|
||||
virtual void powerOff() override {
|
||||
((CustomSX1262 *)_radio)->sleep(false);
|
||||
}
|
||||
|
||||
@@ -11,6 +11,15 @@
|
||||
class CustomSX1268Wrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomSX1268Wrapper(CustomSX1268& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomSX1268 *)_radio)->setFrequency(freq);
|
||||
((CustomSX1268 *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomSX1268 *)_radio)->setBandwidth(bw);
|
||||
((CustomSX1268 *)_radio)->setCodingRate(cr);
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1268 *)_radio)->isReceiving();
|
||||
}
|
||||
@@ -24,6 +33,7 @@ public:
|
||||
int sf = ((CustomSX1268 *)_radio)->spreadingFactor;
|
||||
return packetScoreInt(snr, sf, packet_len);
|
||||
}
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomSX1268 *)_radio)->spreadingFactor; }
|
||||
|
||||
void doResetAGC() override { sx126xResetAGC((SX126x *)_radio); }
|
||||
|
||||
|
||||
@@ -10,6 +10,15 @@
|
||||
class CustomSX1276Wrapper : public RadioLibWrapper {
|
||||
public:
|
||||
CustomSX1276Wrapper(CustomSX1276& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
|
||||
|
||||
void setParams(float freq, float bw, uint8_t sf, uint8_t cr) override {
|
||||
((CustomSX1276 *)_radio)->setFrequency(freq);
|
||||
((CustomSX1276 *)_radio)->setSpreadingFactor(sf);
|
||||
((CustomSX1276 *)_radio)->setBandwidth(bw);
|
||||
((CustomSX1276 *)_radio)->setCodingRate(cr);
|
||||
updatePreamble(sf);
|
||||
}
|
||||
|
||||
bool isReceivingPacket() override {
|
||||
return ((CustomSX1276 *)_radio)->isReceiving();
|
||||
}
|
||||
@@ -23,4 +32,5 @@ public:
|
||||
int sf = ((CustomSX1276 *)_radio)->spreadingFactor;
|
||||
return packetScoreInt(snr, sf, packet_len);
|
||||
}
|
||||
uint8_t getSpreadingFactor() const override { return ((CustomSX1276 *)_radio)->spreadingFactor; }
|
||||
};
|
||||
@@ -26,6 +26,8 @@ void setFlag(void) {
|
||||
|
||||
void RadioLibWrapper::begin() {
|
||||
_radio->setPacketReceivedAction(setFlag); // this is also SentComplete interrupt
|
||||
_preamble_sf = getSpreadingFactor();
|
||||
_radio->setPreambleLength(preambleLengthForSF(_preamble_sf)); // longer preamble for lower SF improves reliability
|
||||
state = STATE_IDLE;
|
||||
|
||||
if (_board->getStartupReason() == BD_STARTUP_RX_PACKET) { // received a LoRa packet (while in deep sleep)
|
||||
@@ -40,6 +42,14 @@ void RadioLibWrapper::begin() {
|
||||
_floor_sample_sum = 0;
|
||||
}
|
||||
|
||||
uint32_t RadioLibWrapper::getRngSeed() {
|
||||
return _radio->random(0x7FFFFFFF);
|
||||
}
|
||||
|
||||
void RadioLibWrapper::setTxPower(int8_t dbm) {
|
||||
_radio->setOutputPower(dbm);
|
||||
}
|
||||
|
||||
void RadioLibWrapper::idle() {
|
||||
_radio->standby();
|
||||
state = STATE_IDLE; // need another startReceive()
|
||||
|
||||
@@ -11,6 +11,7 @@ protected:
|
||||
int16_t _noise_floor, _threshold;
|
||||
uint16_t _num_floor_samples;
|
||||
int32_t _floor_sample_sum;
|
||||
uint8_t _preamble_sf;
|
||||
|
||||
void idle();
|
||||
void startRecv();
|
||||
@@ -19,7 +20,7 @@ protected:
|
||||
virtual void doResetAGC();
|
||||
|
||||
public:
|
||||
RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board) { n_recv = n_sent = 0; }
|
||||
RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board), _preamble_sf(0) { n_recv = n_sent = 0; }
|
||||
|
||||
void begin() override;
|
||||
virtual void powerOff() { _radio->sleep(); }
|
||||
@@ -37,7 +38,14 @@ public:
|
||||
return isChannelActive();
|
||||
}
|
||||
|
||||
virtual void setParams(float freq, float bw, uint8_t sf, uint8_t cr) = 0;
|
||||
uint32_t getRngSeed();
|
||||
void setTxPower(int8_t dbm);
|
||||
|
||||
virtual float getCurrentRSSI() =0;
|
||||
virtual uint8_t getSpreadingFactor() const { return LORA_SF; }
|
||||
static uint16_t preambleLengthForSF(uint8_t sf) { return sf <= 8 ? 32 : 16; }
|
||||
void updatePreamble(uint8_t sf) { _preamble_sf = sf; _radio->setPreambleLength(preambleLengthForSF(sf)); }
|
||||
|
||||
int getNoiseFloor() const override { return _noise_floor; }
|
||||
void triggerNoiseFloorCalibrate(int threshold) override;
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -6,26 +6,22 @@
|
||||
|
||||
class EnvironmentSensorManager : public SensorManager {
|
||||
protected:
|
||||
int next_available_channel = TELEM_CHANNEL_SELF + 1;
|
||||
static const int MAX_ACTIVE_SENSORS = 16;
|
||||
|
||||
bool AHTX0_initialized = false;
|
||||
bool BME280_initialized = false;
|
||||
bool BMP280_initialized = false;
|
||||
bool INA3221_initialized = false;
|
||||
bool INA219_initialized = false;
|
||||
bool INA260_initialized = false;
|
||||
bool INA226_initialized = false;
|
||||
bool SHTC3_initialized = false;
|
||||
bool LPS22HB_initialized = false;
|
||||
bool MLX90614_initialized = false;
|
||||
bool VL53L0X_initialized = false;
|
||||
bool SHT4X_initialized = false;
|
||||
bool BME680_initialized = false;
|
||||
bool BMP085_initialized = false;
|
||||
// Query function pointer + sub-channel index (for multi-channel sensors like INA3221).
|
||||
// Sub-channel is 0 for all single-output sensors.
|
||||
struct ActiveSensor {
|
||||
void (*query)(uint8_t channel, uint8_t sub_channel, CayenneLPP& telemetry);
|
||||
uint8_t sub_channel;
|
||||
};
|
||||
|
||||
bool gps_detected = false;
|
||||
bool gps_active = false;
|
||||
uint32_t gps_update_interval_sec = 1; // Default 1 second
|
||||
ActiveSensor _active_sensors[MAX_ACTIVE_SENSORS];
|
||||
int _active_sensor_count = 0;
|
||||
uint8_t next_available_channel = TELEM_CHANNEL_SELF + 1;
|
||||
|
||||
bool gps_detected = false;
|
||||
bool gps_active = false;
|
||||
uint32_t gps_update_interval_sec = 1;
|
||||
|
||||
#if ENV_INCLUDE_GPS
|
||||
LocationProvider* _location;
|
||||
@@ -38,7 +34,6 @@ protected:
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
public:
|
||||
#if ENV_INCLUDE_GPS
|
||||
EnvironmentSensorManager(LocationProvider &location): _location(&location){};
|
||||
@@ -48,7 +43,7 @@ public:
|
||||
#endif
|
||||
bool begin() override;
|
||||
bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
|
||||
#if ENV_INCLUDE_GPS
|
||||
#if ENV_INCLUDE_GPS || defined(ENV_INCLUDE_BME680_BSEC)
|
||||
void loop() override;
|
||||
#endif
|
||||
int getNumSettings() const override;
|
||||
|
||||
@@ -0,0 +1,554 @@
|
||||
/*----------------------------------------------------------------------*
|
||||
* RAK12035_SoilMoistureSensor.cpp - Arduino library for the Sensor *
|
||||
* version of I2C Soil Moisture Sensor version from Chrirp *
|
||||
* (https://github.com/Miceuz/i2c-moisture-sensor). *
|
||||
* *
|
||||
* Ingo Fischer 11Nov2015 *
|
||||
* https://github.com/Apollon77/I2CSoilMoistureSensor *
|
||||
* *
|
||||
* Ken Privitt 8Feb2026 *
|
||||
* Adapted for MeshCore Firmware Stack *
|
||||
* *
|
||||
* MIT license *
|
||||
* *
|
||||
* This file contains a collection of routines to access the *
|
||||
* RAK12035 Soil Moisture Sensor via I2C. The sensor provides *
|
||||
* Soil Temperature and capacitance-based Soil Moisture Readings. *
|
||||
* *
|
||||
*----------------------------------------------------------------------*/
|
||||
|
||||
#include "RAK12035_SoilMoisture.h"
|
||||
#include "MeshCore.h"
|
||||
#include <Wire.h>
|
||||
|
||||
/*----------------------------------------------------------------------*
|
||||
* Constructor. *
|
||||
*----------------------------------------------------------------------*/
|
||||
// RAK12035_SoilMoisture(uint8_t addr)
|
||||
//
|
||||
// Accepts the I2C Address to look for the RAK12035
|
||||
// Initializes the I2C to null (will be setup later in Wire.Begin()
|
||||
//
|
||||
// No hardware is touched in the constructor.
|
||||
// I2C communication is deferred until begin() is called.
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
RAK12035_SoilMoisture::RAK12035_SoilMoisture(uint8_t addr)
|
||||
{
|
||||
_addr = addr; // Save the sensor's I2C address
|
||||
_i2c = nullptr; // Bus not assigned yet; must be set in begin()
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// setup()
|
||||
//------------------------------------------------------------------------------
|
||||
// setup(TwoWire &i2c)
|
||||
//
|
||||
// Assigns the I2C bus that this driver instance will use. This allows the
|
||||
// application to choose between Wire, Wire1, or any other TwoWire instance
|
||||
// supported by the platform.
|
||||
//
|
||||
// No I2C communication occurs here; setup() simply stores the pointer so that
|
||||
// begin() and all register‑level operations know which bus to use.
|
||||
//------------------------------------------------------------------------------
|
||||
void RAK12035_SoilMoisture::setup(TwoWire &i2c)
|
||||
|
||||
{
|
||||
_i2c = &i2c; // assigns the bus pointer
|
||||
_i2c->begin(); // Initialize the bus to Wire or Wire1
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// RAK12035 Soil Moisture begin()
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// Performs initialization of the RAK12035 soil‑moisture sensor. This
|
||||
// routine assumes that the application has already selected the I2C bus via
|
||||
// setup() and that the bus has been initialized externally (Wire.begin()).
|
||||
// It uses the passed in I2C Address (default 0x20)
|
||||
//
|
||||
// *** This code does not support three sensors ***
|
||||
// The RAK12023 has three connectors, but each of the sensors attached must
|
||||
// all have different I2C addresses.
|
||||
// This code has a function to set the I2C address of a sensor
|
||||
// and currently only supports one address 0x20 (the default).
|
||||
// To support three sensors, EnvironmentSensorManager would need to be modified
|
||||
// to support multiple instances of the RAK12035_SoilMoisture class,
|
||||
// each with a different address. (0x20, 0x21, 0x22)
|
||||
// The begin() function would need to be modified to loop through the three addresses
|
||||
//
|
||||
// DEBUG STATEMENTS: Can be enabled by uncommenting or adding:
|
||||
// File: variants/rak4631 platformio.ini
|
||||
// Section example: [env:RAK_4631_companion_radio_ble]
|
||||
// Enable Debug statements: -D MESH_DEBUG=1
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
bool RAK12035_SoilMoisture::begin(uint8_t addr)
|
||||
{
|
||||
// MESH_DEBUG_PRINTLN("begin() - Start of RAK12035 initialization");
|
||||
// MESH_DEBUG_PRINTLN("begin() - RAK12035 passed in Address %02X", addr);
|
||||
|
||||
// 1. Ensure setup() was called
|
||||
if (_i2c == nullptr) {
|
||||
MESH_DEBUG_PRINTLN("RAK12035 ERROR: I2C bus not set!");
|
||||
return false;
|
||||
}
|
||||
|
||||
uint16_t _dry_cal = 200;
|
||||
uint16_t _wet_cal = 600;
|
||||
uint8_t _version = 0;
|
||||
uint8_t _addr; // The I2C address to be used (passed in parameter)
|
||||
|
||||
/*------------------------------------------------------------------------------------------
|
||||
* Set Calibration values - This is done with custom a firmware version
|
||||
*
|
||||
* USE the Build Flag: -D ENABLE_RAK12035_CALIBRATION = 1
|
||||
* OR
|
||||
* Change the value to 1 in the RAK12035_SoilMoisture.h file
|
||||
*
|
||||
* Calibration Procedure:
|
||||
* 1) Flash the Calibration version of the firmware.
|
||||
* 2) Leave the sensor dry, power up the device.
|
||||
* 3) After detecting the RAK12035 this firmware will display calibration data on Channel 3
|
||||
*
|
||||
* Frequency = Current Capacitance Value
|
||||
* Temperature = Current Wet calibration value
|
||||
* Power = Current Dry calibration value
|
||||
*
|
||||
* 4) Click refresh several times. This will take a capacitance reading and if it is
|
||||
* greater than the current Dry value it will store it in the sensor
|
||||
* The value will bounce a little as you click refresh, but it eventually settles down (a few clicks)
|
||||
* the stored value will stabalize at it's Maximum value.
|
||||
*
|
||||
* 5) Put the sensor in water.
|
||||
*
|
||||
* 6) Click refresh several times. This will take a capacitance reading and if it is
|
||||
* less than the current Wet value it will store it in the sensor
|
||||
* The value will bounce a little as you click refresh, but it eventually settles down (a few clicks)
|
||||
* the stored value will stabalize at it's Minimum value.
|
||||
*
|
||||
* 7) The Sensor is now calibrated, turn off the device.
|
||||
*
|
||||
* 8) Reflash the device with the non-Calibration Firmware, Data will be shown on Channel 2
|
||||
*
|
||||
*------------------------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#if ENABLE_RAK12035_CALIBRATION
|
||||
uint16_t _wet = 2000; // A high value the should be out of the normal Wet range
|
||||
set_humidity_full(_wet);
|
||||
|
||||
uint16_t _dry = 50; // A low value the should be out of the normal Dry range
|
||||
set_humidity_zero(_dry);
|
||||
#endif
|
||||
|
||||
/*--------------------------------------------------------------------------------
|
||||
*
|
||||
* Check if a sensor is present and return true if found, false if not present
|
||||
*
|
||||
*--------------------------------------------------------------------------------
|
||||
*/
|
||||
if (query_sensor()) {
|
||||
MESH_DEBUG_PRINTLN("begin() - Sensor responded with valid version");
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
MESH_DEBUG_PRINTLN("begin() - Sensor version FAIL");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------------------
|
||||
*
|
||||
* Below are all the routines to execute the various I2C commands supported
|
||||
* by the RAK12035 sensor
|
||||
*
|
||||
*--------------------------------------------------------------------------------*/
|
||||
|
||||
uint16_t RAK12035_SoilMoisture::get_sensor_capacitance() //Command 01 - (r) 2 byte
|
||||
{
|
||||
uint8_t buf[2] = {0};
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_CAPACITANCE, buf, 2)) {
|
||||
MESH_DEBUG_PRINTLN("Function 1: get_capacitance() FAIL: Bad data returned = %02X %02X", buf[0], buf[1]);
|
||||
return (buf[0] << 8) | buf[1]; // return raw for debugging
|
||||
}
|
||||
uint16_t cap = (buf[0] << 8) | buf[1];
|
||||
MESH_DEBUG_PRINTLN("Function 1: get_capacitance() SUCCESS: Capacitance = %d", cap);
|
||||
return cap;
|
||||
}
|
||||
|
||||
|
||||
uint8_t RAK12035_SoilMoisture::get_I2C_address() //Command 02 - (r) 1 byte
|
||||
{
|
||||
uint8_t addr = 0;
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_I2C_ADDR, &addr, 1)) {
|
||||
MESH_DEBUG_PRINTLN("Function 2: get_I2C_address() FAIL: Bad data returned = %02X", addr);
|
||||
return addr; // return raw for debugging
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 2: get_I2C_address() SUCCESS: I2C Address = %02X", addr);
|
||||
return addr;
|
||||
}
|
||||
|
||||
|
||||
bool RAK12035_SoilMoisture::set_sensor_addr(uint8_t addr) //Command 03 - (w) 1 byte
|
||||
{
|
||||
if (!write_rak12035(SOILMOISTURESENSOR_SET_I2C_ADDR, &addr, 1)) {
|
||||
MESH_DEBUG_PRINTLN("Function 3: set_I2C_address() FAIL: Could not set new address %02X", addr);
|
||||
return false;
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 3: set_I2C_address() SUCCESS: New address = %02X", addr);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
uint8_t RAK12035_SoilMoisture::get_sensor_version() // Command 04 - 1 byte
|
||||
{
|
||||
uint8_t v = 0;
|
||||
|
||||
read_rak12035(SOILMOISTURESENSOR_GET_VERSION, &v, 1);
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_VERSION, &v, 1)) {
|
||||
MESH_DEBUG_PRINTLN("Function 4: get_sensor_version() FAIL: Bad data returned = %02X", v);
|
||||
return v;
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 4: get_sensor_version() SUCCESS: Version = %02X", v);
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
float RAK12035_SoilMoisture::get_sensor_temperature() //Command 05 - (r) 2 bytes
|
||||
{
|
||||
uint8_t buf[2] = {0};
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_TEMPERATURE, buf, 2)) {
|
||||
MESH_DEBUG_PRINTLN("Function 5: get_temperature() FAIL: Bad data returned = %02X %02X", buf[0], buf[1]);
|
||||
return (buf[0] << 8) | buf[1]; // raw data returned for debugging 0XFFFF is error
|
||||
}
|
||||
// Sensor returns a 16-bit signed integer (°C * 10)
|
||||
int16_t raw = (buf[0] << 8) | buf[1];
|
||||
float tempC = raw / 10.0f;
|
||||
MESH_DEBUG_PRINTLN("Function 5: get_temperature() SUCCESS: Raw=%04X Temp=%.1f C", raw, tempC);
|
||||
return tempC;
|
||||
}
|
||||
|
||||
|
||||
bool RAK12035_SoilMoisture::sensor_sleep() //Command 06 - (w) 1 byte
|
||||
{
|
||||
uint8_t tmp = 0;
|
||||
if (!write_rak12035(SOILMOISTURESENSOR_SET_SLEEP, &tmp, 1)) {
|
||||
MESH_DEBUG_PRINTLN("Function 6: sensor_sleep() FAIL: Could not send sleep command");
|
||||
return false;
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 6: sensor_sleep() SUCCESS: Sensor acknowledged sleep command");
|
||||
|
||||
// Optional: turn off sensor power AFTER successful sleep command
|
||||
|
||||
// This has been commented out due to a pin name conflict with the Heltec v3
|
||||
// This will need to be resolved if this function is to be utilized in the future
|
||||
/*
|
||||
digitalWrite(WB_IO2, LOW);
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool RAK12035_SoilMoisture::set_humidity_full(uint16_t full) //Command 07 - (w) 2 bytes
|
||||
{
|
||||
uint8_t buf[2];
|
||||
buf[0] = (full >> 8) & 0xFF; // High byte
|
||||
buf[1] = full & 0xFF; // Low byte
|
||||
|
||||
if (!write_rak12035(SOILMOISTURESENSOR_SET_WET_CAL, buf, 2)) {
|
||||
MESH_DEBUG_PRINTLN("Function 7: set_humidity_full() FAIL: Could not set wet calibration value"
|
||||
);
|
||||
return false;
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 7: set_humidity_full() SUCCESS: New Full = %04X", full);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool RAK12035_SoilMoisture::set_humidity_zero(uint16_t zero) //Command 08 - (w) 2 bytes
|
||||
{
|
||||
uint8_t buf[2];
|
||||
buf[0] = (zero >> 8) & 0xFF; // High byte
|
||||
buf[1] = zero & 0xFF; // Low byte
|
||||
|
||||
if (!write_rak12035(SOILMOISTURESENSOR_SET_DRY_CAL, buf, 2)) {
|
||||
MESH_DEBUG_PRINTLN("Function 8: set_humidity_zero() FAIL: Could not set dry calibration value");
|
||||
return false;
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 8: set_humidity_zero() SUCCESS: New Zero = %04X", zero);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
uint8_t RAK12035_SoilMoisture::get_sensor_moisture() //Command 09 - (r) 1 byte
|
||||
{
|
||||
// Load calibration values from sensor
|
||||
_wet_cal = get_humidity_full();
|
||||
_dry_cal = get_humidity_zero();
|
||||
|
||||
MESH_DEBUG_PRINTLN("Function 9: get_moisture() - Read from sensor or calculate from capacitance");
|
||||
|
||||
// Read sensor version
|
||||
uint8_t v = get_sensor_version();
|
||||
|
||||
// If version > 2, read moisture directly from the sensor
|
||||
if (v > 2) {
|
||||
MESH_DEBUG_PRINTLN("Version > 02 - Reading moisture directly from sensor");
|
||||
uint8_t moisture = get_sensor_humid();
|
||||
MESH_DEBUG_PRINTLN("get_moisture() Direct Read = %d%%", moisture);
|
||||
return moisture;
|
||||
}
|
||||
// Otherwise calculate moisture from capacitance
|
||||
MESH_DEBUG_PRINTLN("Calculating moisture from capacitance");
|
||||
|
||||
uint16_t cap = get_sensor_capacitance();
|
||||
|
||||
// Clamp capacitance between calibration points
|
||||
if (_dry_cal < _wet_cal) {
|
||||
if (cap <= _dry_cal) cap = _dry_cal;
|
||||
if (cap >= _wet_cal) cap = _wet_cal;
|
||||
|
||||
float pct = (_wet_cal - cap) * 100.0f / (_wet_cal - _dry_cal);
|
||||
if (pct > 100.0f) pct = 100.0f;
|
||||
|
||||
MESH_DEBUG_PRINTLN("get_moisture Case 1() Calculated = %d%%", (uint8_t)pct);
|
||||
return (uint8_t)pct;
|
||||
} else {
|
||||
if (cap >= _dry_cal) cap = _dry_cal;
|
||||
if (cap <= _wet_cal) cap = _wet_cal;
|
||||
|
||||
float pct = (_dry_cal - cap) * 100.0f / (_dry_cal - _wet_cal);
|
||||
if (pct > 100.0f) pct = 100.0f;
|
||||
|
||||
MESH_DEBUG_PRINTLN("get_moisture Case 2() Calculated = %d%%", (uint8_t)pct);
|
||||
return (uint8_t)pct;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint8_t RAK12035_SoilMoisture::get_sensor_humid() //Command 09 - (r) 1 byte
|
||||
{
|
||||
uint8_t moisture = 0;
|
||||
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_MOISTURE, &moisture, 1)) {
|
||||
MESH_DEBUG_PRINTLN("Function 9: get_sensor_humid() FAIL: Bad data returned = %02X", moisture);
|
||||
return moisture; // raw fallback
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("Function 9: get_sensor_humid() SUCCESS: Moisture = %d%%",moisture);
|
||||
return moisture;
|
||||
}
|
||||
|
||||
|
||||
uint16_t RAK12035_SoilMoisture::get_humidity_full() //Command 0A - (r) 2 bytes
|
||||
{
|
||||
uint8_t buf[2] = {0};
|
||||
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_WET_CAL, buf, 2)) {
|
||||
MESH_DEBUG_PRINTLN("Function A: get_humidity_full() FAIL: Bad data returned = %02X%02X", buf[0], buf[1]);
|
||||
return 0xFFFF; // error indicator
|
||||
}
|
||||
|
||||
uint16_t full = (buf[0] << 8) | buf[1];
|
||||
|
||||
MESH_DEBUG_PRINTLN("Function A: get_humidity_full() SUCCESS: Full = %04X = %d", full, full);
|
||||
return full;
|
||||
}
|
||||
|
||||
|
||||
uint16_t RAK12035_SoilMoisture::get_humidity_zero() //Command 0B - 2 bytes
|
||||
{
|
||||
uint8_t buf[2] = {0};
|
||||
|
||||
if (!read_rak12035(SOILMOISTURESENSOR_GET_DRY_CAL, buf, 2)) {
|
||||
MESH_DEBUG_PRINTLN("Function B: get_humidity_zero() FAIL: Bad data returned = %02X%02X", buf[0], buf[1]);
|
||||
return 0xFFFF; // error indicator
|
||||
}
|
||||
|
||||
uint16_t zero = (buf[0] << 8) | buf[1];
|
||||
|
||||
MESH_DEBUG_PRINTLN("Function B: get_humidity_zero() SUCCESS: Zero = %04X = %d", zero, zero);
|
||||
return zero;
|
||||
}
|
||||
|
||||
|
||||
/*------------------------------------------------------------------------------------------*
|
||||
* getEvent() - High-level function to read both moisture and temperature in one call. *
|
||||
*------------------------------------------------------------------------------------------*
|
||||
* This function reads the moisture percentage and temperature from the sensor and returns *
|
||||
* them via output parameters. This may be used for the telemetry delivery in the MeshCore *
|
||||
* firmware, with a single function to get all sensor data. *
|
||||
* *
|
||||
* The function returns true if both readings were successfully obtained, or false if any *
|
||||
* error occurred during I2C communication. *
|
||||
* *
|
||||
* This function is currently not used *
|
||||
*------------------------------------------------------------------------------------------*/
|
||||
bool RAK12035_SoilMoisture::getEvent(uint8_t *humidity, uint16_t *temp)
|
||||
{
|
||||
// Read moisture (0-100%)
|
||||
uint8_t moist = get_sensor_moisture();
|
||||
if (moist == 0xFF) //error indicator
|
||||
return false;
|
||||
MESH_DEBUG_PRINTLN("getEvent() - Humidity = %d", moist);
|
||||
*humidity = moist;
|
||||
|
||||
//Read temperature (degrees C)
|
||||
uint16_t t = get_sensor_temperature();
|
||||
if (t == 0XFFFF) // error indicator
|
||||
return false;
|
||||
|
||||
*temp = t;
|
||||
MESH_DEBUG_PRINTLN("getEvent() - Temperature = %d", t);
|
||||
return true;
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------------------*
|
||||
* Sensor Power Management and Reset Routines
|
||||
*
|
||||
* These routines manage the power and reset state of the sensor. The sensor_on() routine is
|
||||
* designed to power on the sensor and wait for it to become responsive, while the reset()
|
||||
* routine toggles the reset pin and waits for the sensor to respond with a valid version.
|
||||
*
|
||||
* They are for a future sensor power management function.
|
||||
*------------------------------------------------------------------------------------------*/
|
||||
|
||||
bool RAK12035_SoilMoisture::sensor_on()
|
||||
{
|
||||
uint8_t data;
|
||||
// This has been commented out due to a pin name conflict with the Heltec v3
|
||||
// This will need to be resolved if this function is to be utilized in the future
|
||||
|
||||
/*
|
||||
pinMode(WB_IO2, OUTPUT);
|
||||
digitalWrite(WB_IO2, HIGH); //Turn on Sensor Power
|
||||
|
||||
pinMode(WB_IO4, OUTPUT); //Set IO4 Pin to Output (connected to *reset on sensor)
|
||||
digitalWrite(WB_IO4, LOW); //*reset - Reset the Sensor
|
||||
delay(1); //Wait for the minimum *reset, 1mS is longer than required minimum
|
||||
digitalWrite(WB_IO4, HIGH); //Deassert Reset
|
||||
|
||||
delay(10); // Wait for the sensor code to complete initialization
|
||||
*/
|
||||
uint8_t v = 0;
|
||||
uint32_t timeout = millis();
|
||||
while ((!query_sensor())) //Wait for sensor to respond to I2C commands,
|
||||
{ //indicating it is ready
|
||||
if ((millis() - timeout) > 50){ //0.5 second timeout for sensor to respond
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout, no response from I2C commands");
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
delay(10); //delay 10mS
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool RAK12035_SoilMoisture::reset()
|
||||
{
|
||||
// This function is for a future Sensor Power Management function.
|
||||
// When power is reapplied this will reset the sensor and wait for it to respond
|
||||
// with a valid version.
|
||||
//
|
||||
// The Atmel 8495 Microcoltroller: Reset input. A low level on this pin for longer than
|
||||
// the minimum pulse length will generate a reset, even if the clock is not
|
||||
// running and provided the reset pin has not been disabled. The minimum pulse length is
|
||||
// given in Table 25-5 on page 240. 2000ns = .002mS
|
||||
// Shorter pulses are not guaranteed to generate a reset.
|
||||
//
|
||||
// Power is never removed so the Sensor reset was removed and is not needed,
|
||||
// But might be needed if power is ever switched off. Here is tested code.
|
||||
|
||||
// This has been commented out due to a pin name conflict with the Heltec v3
|
||||
// This will need to be resolved if this function is to be utilized in the future
|
||||
|
||||
/*
|
||||
pinMode(WB_IO4, OUTPUT); //Set IO4 Pin to Output (connected to *reset on sensor)
|
||||
MESH_DEBUG_PRINTLN("Assert *reset (Low) for 1 mS");
|
||||
digitalWrite(WB_IO4, LOW); //Reset the Sensor
|
||||
delay(1); //Wait for the minimum *reset, 1mS is longer than required minimum
|
||||
MESH_DEBUG_PRINTLN("reset() - De-assert *reset (High)");
|
||||
digitalWrite(WB_IO4, HIGH); // Deassert Reset
|
||||
*/
|
||||
|
||||
MESH_DEBUG_PRINTLN("reset() - Begin poling in 100mS intervals for a non-zero version");
|
||||
uint32_t start_time = millis();
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout, Start Time: %d milliseconds", start_time);
|
||||
|
||||
const uint32_t timeout_ms = 500; // Wait for 0.5 seconds
|
||||
uint32_t start = millis();
|
||||
|
||||
while (true) {
|
||||
if (query_sensor()) {
|
||||
MESH_DEBUG_PRINTLN("reset() - First Pass, Sensor responded with valid version");
|
||||
uint32_t stop_time = millis();
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout, Stop Time: %d mS", stop_time);
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout, Duration: %d mS", (stop_time - start_time));
|
||||
|
||||
return true;
|
||||
}
|
||||
if (millis() - start > timeout_ms) {
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout waiting for valid sensor version");
|
||||
uint32_t stop_time = millis();
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout, Stop Time: %d mS", stop_time);
|
||||
MESH_DEBUG_PRINTLN("reset() - Timeout, Duration: %d mS", (stop_time - start_time));
|
||||
return false;
|
||||
}
|
||||
delay(100);
|
||||
}
|
||||
}
|
||||
|
||||
bool RAK12035_SoilMoisture::query_sensor()
|
||||
{
|
||||
uint8_t v = 0;
|
||||
v = get_sensor_version();
|
||||
|
||||
// Treat 0x00 and 0xFF as invalid / bootloader / garbage
|
||||
if (v == 0x00 || v == 0xFF) {
|
||||
MESH_DEBUG_PRINTLN("query_sensor() FAIL: Version value invalid: %02X", v);
|
||||
return false;
|
||||
}
|
||||
MESH_DEBUG_PRINTLN("query_sensor() SUCCESS: Sensor Present, Version = %02X", v);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/*------------------------------------------------------------------------------------------*
|
||||
* Below are the low-level I2C read and write functions. These handle the actual
|
||||
* communication with the sensor registers. The higher-level functions call these
|
||||
* to perform specific tasks.
|
||||
*------------------------------------------------------------------------------------------*/
|
||||
|
||||
bool RAK12035_SoilMoisture::read_rak12035(uint8_t cmd, uint8_t *data, uint8_t length)
|
||||
{
|
||||
_i2c->beginTransmission(_addr);
|
||||
_i2c->write(cmd); // <-- COMMAND, not register index
|
||||
if (_i2c->endTransmission() != 0)
|
||||
return false;
|
||||
|
||||
delay(20);
|
||||
|
||||
int received = _i2c->requestFrom(_addr, length);
|
||||
if (received != length)
|
||||
return false;
|
||||
|
||||
for (int i = 0; i < length; i++)
|
||||
data[i] = _i2c->read();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RAK12035_SoilMoisture::write_rak12035(uint8_t cmd, uint8_t *data, uint8_t length)
|
||||
{
|
||||
_i2c->beginTransmission(_addr);
|
||||
_i2c->write(cmd); // <-- COMMAND, not register index
|
||||
|
||||
for (uint8_t i = 0; i < length; i++)
|
||||
_i2c->write(data[i]);
|
||||
|
||||
if (_i2c->endTransmission() != 0)
|
||||
return false;
|
||||
|
||||
delay(20);
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
/**
|
||||
* @file RAK12035_SoilMoisture.h
|
||||
* @author Bernd Giesecke (bernd.giesecke@rakwireless.com)
|
||||
* @brief Header file for Class RAK12035
|
||||
* @version 0.1
|
||||
* @date 2021-11-20
|
||||
*
|
||||
* Updates for MeshCore integration
|
||||
* Ken Privitt
|
||||
* 2/26/2026
|
||||
*
|
||||
* @copyright Copyright (c) 2021
|
||||
*
|
||||
*/
|
||||
#ifndef RAK12035_SOILMOISTURE_H
|
||||
#define RAK12035_SOILMOISTURE_H
|
||||
#endif
|
||||
|
||||
#ifndef ENABLE_RAK12025_CALIBRATION
|
||||
#define ENABLE_RAK12025_CALIBRATION = 0 // Used to generate Calibration Version of Firmware
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <Wire.h>
|
||||
|
||||
#define RAK12035_I2C_ADDR_DEFAULT 0x20
|
||||
#define RAK12035_0_ADDR 0x20
|
||||
#define RAK12035_1_ADDR 0x21
|
||||
#define RAK12035_2_ADDR 0x22
|
||||
|
||||
// Command codes used by the RAK12035 firmware
|
||||
#define SOILMOISTURESENSOR_GET_CAPACITANCE 0x01 // (r) 2 bytes
|
||||
#define SOILMOISTURESENSOR_GET_I2C_ADDR 0x02 // (r) 1 bytes
|
||||
#define SOILMOISTURESENSOR_SET_I2C_ADDR 0x03 // (w) 1 bytes
|
||||
#define SOILMOISTURESENSOR_GET_VERSION 0x04 // (r) 1 bytes
|
||||
#define SOILMOISTURESENSOR_GET_TEMPERATURE 0x05 // (r) 2 bytes
|
||||
#define SOILMOISTURESENSOR_SET_SLEEP 0x06 // (w) 1 bytes
|
||||
#define SOILMOISTURESENSOR_SET_WET_CAL 0x07 // (w) 2 bytes
|
||||
#define SOILMOISTURESENSOR_SET_DRY_CAL 0x08 // (w) 2 bytes
|
||||
#define SOILMOISTURESENSOR_GET_MOISTURE 0x09 // (r) 1 bytes
|
||||
#define SOILMOISTURESENSOR_GET_WET_CAL 0x0A // (r) 2 bytes
|
||||
#define SOILMOISTURESENSOR_GET_DRY_CAL 0x0B // (r) 2 bytes
|
||||
|
||||
class RAK12035_SoilMoisture
|
||||
{
|
||||
public:
|
||||
RAK12035_SoilMoisture(uint8_t addr = RAK12035_I2C_ADDR_DEFAULT);
|
||||
|
||||
void setup(TwoWire& i2c);
|
||||
bool begin(uint8_t addr);
|
||||
bool getEvent(uint8_t *humidity, uint16_t *temperature);
|
||||
|
||||
uint16_t get_sensor_capacitance(); //Command 01 - (r) 2 byte
|
||||
uint8_t get_I2C_address(); //Command 02 - (r) 1 byte
|
||||
bool set_sensor_addr(uint8_t addr); //Command 03 - (w) 1 byte
|
||||
uint8_t get_sensor_version(); //Command 04 - (r) 1 byte
|
||||
float get_sensor_temperature(); //Command 05 - (r) 2 bytes
|
||||
bool sensor_sleep(); //Command 06 - (w) 1 byte
|
||||
bool set_humidity_full(uint16_t hundred_val); //Command 07 - (w) 2 bytes
|
||||
bool set_humidity_zero(uint16_t zero_val); //Command 08 - (w) 2 bytes
|
||||
uint8_t get_sensor_moisture(); //Command 09 - (r) 1 byte
|
||||
uint8_t get_sensor_humid(); //Command 09 - (r) 1 byte
|
||||
uint16_t get_humidity_full(); //Command 0A - (r) 2 bytes
|
||||
uint16_t get_humidity_zero(); //Command 0B - (r) 2 bytes
|
||||
|
||||
bool read_rak12035(uint8_t cmd, uint8_t *data, uint8_t length);
|
||||
bool write_rak12035(uint8_t cmd, uint8_t *data, uint8_t length);
|
||||
|
||||
bool query_sensor();
|
||||
bool sensor_on();
|
||||
bool reset();
|
||||
|
||||
uint16_t _dry_cal;
|
||||
uint16_t _wet_cal;
|
||||
|
||||
private:
|
||||
bool read_reg(uint8_t reg, uint8_t *data, uint8_t len);
|
||||
bool write_reg(uint8_t reg, uint8_t *data, uint8_t len);
|
||||
|
||||
TwoWire *_i2c = &Wire;
|
||||
uint8_t _addr;
|
||||
|
||||
uint16_t default_dry_cal = 2000;
|
||||
uint16_t default_wet_cal = 50;
|
||||
uint8_t _capacitance = 0;
|
||||
uint16_t _temperature = 0;
|
||||
uint8_t _moisture = 0;
|
||||
};
|
||||
#endif
|
||||
@@ -14,6 +14,7 @@ public:
|
||||
int height() const { return _h; }
|
||||
|
||||
virtual bool isOn() = 0;
|
||||
virtual bool isEink() { return false; } // default to non-eink, override in eink drivers
|
||||
virtual void turnOn() = 0;
|
||||
virtual void turnOff() = 0;
|
||||
virtual void clear() = 0;
|
||||
|
||||
@@ -26,6 +26,7 @@ public:
|
||||
}
|
||||
bool begin();
|
||||
bool isOn() override { return _isOn; }
|
||||
bool isEink() override { return true; }
|
||||
void turnOn() override;
|
||||
void turnOff() override;
|
||||
void clear() override;
|
||||
|
||||
@@ -22,6 +22,7 @@ public:
|
||||
|
||||
bool begin();
|
||||
bool isOn() override { return _isOn; }
|
||||
bool isEink() override { return true; }
|
||||
void turnOn() override;
|
||||
void turnOff() override;
|
||||
void clear() override;
|
||||
|
||||
@@ -46,7 +46,8 @@ public:
|
||||
|
||||
bool begin();
|
||||
|
||||
bool isOn() override {return _isOn;};
|
||||
bool isOn() override { return _isOn; }
|
||||
bool isEink() override { return true; }
|
||||
void turnOn() override;
|
||||
void turnOff() override;
|
||||
void clear() override;
|
||||
|
||||
@@ -842,11 +842,11 @@ void OLEDDisplay::drawLogBuffer(uint16_t xMove, uint16_t yMove) {
|
||||
uint16_t lastPos = 0;
|
||||
|
||||
for (uint16_t i=0;i<this->logBufferFilled;i++){
|
||||
// Everytime we have a \n print
|
||||
// Every time we have a \n print
|
||||
if (this->logBuffer[i] == 10) {
|
||||
length++;
|
||||
// Draw string on line `line` from lastPos to length
|
||||
// Passing 0 as the lenght because we are in TEXT_ALIGN_LEFT
|
||||
// Passing 0 as the length because we are in TEXT_ALIGN_LEFT
|
||||
drawStringInternal(xMove, yMove + (line++) * lineHeight, &this->logBuffer[lastPos], length, 0, false);
|
||||
// Remember last pos
|
||||
lastPos = i;
|
||||
@@ -1155,7 +1155,7 @@ void OLEDDisplay::setFontTableLookupFunction(FontTableLookupFunction function) {
|
||||
|
||||
char DefaultFontTableLookup(const uint8_t ch) {
|
||||
// UTF-8 to font table index converter
|
||||
// Code form http://playground.arduino.cc/Main/Utf8ascii
|
||||
// Code from http://playground.arduino.cc/Main/Utf8ascii
|
||||
static uint8_t LASTCHAR;
|
||||
|
||||
if (ch < 128) { // Standard ASCII-set 0..0x7F handling
|
||||
|
||||
@@ -60,7 +60,7 @@ private:
|
||||
};
|
||||
|
||||
#else
|
||||
#error "Unkown operating system"
|
||||
#error "Unknown operating system"
|
||||
#endif
|
||||
|
||||
#include "OLEDDisplayFonts.h"
|
||||
@@ -160,7 +160,7 @@ class OLEDDisplay : public Print {
|
||||
#elif __MBED__
|
||||
class OLEDDisplay : public Stream {
|
||||
#else
|
||||
#error "Unkown operating system"
|
||||
#error "Unknown operating system"
|
||||
#endif
|
||||
|
||||
public:
|
||||
|
||||
@@ -21,10 +21,17 @@ bool ST7735Display::begin() {
|
||||
if (_peripher_power) _peripher_power->claim();
|
||||
|
||||
pinMode(PIN_TFT_LEDA_CTL, OUTPUT);
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, HIGH);
|
||||
#if defined(PIN_TFT_LEDA_CTL_ACTIVE)
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, PIN_TFT_LEDA_CTL_ACTIVE);
|
||||
#else
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, HIGH);
|
||||
#endif
|
||||
digitalWrite(PIN_TFT_RST, HIGH);
|
||||
|
||||
#if defined(HELTEC_TRACKER_V2)
|
||||
#if defined(HELTEC_T1)
|
||||
display.initR(INITR_MINI160x80);
|
||||
display.setRotation(DISPLAY_ROTATION);
|
||||
#elif defined(HELTEC_TRACKER_V2) || defined(HELTEC_T096)
|
||||
display.initR(INITR_MINI160x80);
|
||||
display.setRotation(DISPLAY_ROTATION);
|
||||
uint8_t madctl = ST77XX_MADCTL_MY | ST77XX_MADCTL_MV |ST7735_MADCTL_BGR;//Adjust color to BGR
|
||||
@@ -50,9 +57,12 @@ void ST7735Display::turnOn() {
|
||||
|
||||
void ST7735Display::turnOff() {
|
||||
if (_isOn) {
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, HIGH);
|
||||
digitalWrite(PIN_TFT_RST, LOW);
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, LOW);
|
||||
#if defined(PIN_TFT_LEDA_CTL_ACTIVE)
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, !PIN_TFT_LEDA_CTL_ACTIVE);
|
||||
#else
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, LOW);
|
||||
#endif
|
||||
_isOn = false;
|
||||
|
||||
if (_peripher_power) _peripher_power->release();
|
||||
|
||||
@@ -27,12 +27,6 @@ bool ST7789LCDDisplay::begin() {
|
||||
pinMode(PIN_TFT_LEDA_CTL, OUTPUT);
|
||||
digitalWrite(PIN_TFT_LEDA_CTL, HIGH);
|
||||
}
|
||||
if (PIN_TFT_RST != -1) {
|
||||
pinMode(PIN_TFT_RST, OUTPUT);
|
||||
digitalWrite(PIN_TFT_RST, LOW);
|
||||
delay(10);
|
||||
digitalWrite(PIN_TFT_RST, HIGH);
|
||||
}
|
||||
|
||||
// Im not sure if this is just a t-deck problem or not, if your display is slow try this.
|
||||
#if defined(LILYGO_TDECK) || defined(HELTEC_LORA_V4_TFT)
|
||||
@@ -166,4 +160,4 @@ uint16_t ST7789LCDDisplay::getTextWidth(const char* str) {
|
||||
|
||||
void ST7789LCDDisplay::endFrame() {
|
||||
// display.display();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
#pragma once
|
||||
|
||||
#include "DisplayDriver.h"
|
||||
#include <U8g2lib.h>
|
||||
#include <Wire.h>
|
||||
|
||||
#ifndef DISPLAY_ADDRESS
|
||||
#define DISPLAY_ADDRESS 0x3C
|
||||
#endif
|
||||
|
||||
#ifndef OLED_WIDTH
|
||||
#define OLED_WIDTH 72
|
||||
#endif
|
||||
|
||||
#ifndef OLED_HEIGHT
|
||||
#define OLED_HEIGHT 40
|
||||
#endif
|
||||
|
||||
class U8g2Display : public DisplayDriver {
|
||||
// U8g2 constructor for SSD1306/SSD1315 72×40 panel — handles all
|
||||
// GDDRAM column/page offsets, SETMULTIPLEX, SETDISPLAYOFFSET internally
|
||||
U8G2_SSD1306_72X40_ER_F_HW_I2C _u8g2;
|
||||
bool _isOn;
|
||||
uint8_t _drawColor;
|
||||
|
||||
// Font metrics for current font (cached on setTextSize)
|
||||
uint8_t _fontAscent;
|
||||
uint8_t _fontHeight;
|
||||
|
||||
void applyFont(int sz) {
|
||||
if (sz >= 2) {
|
||||
_u8g2.setFont(u8g2_font_6x10_mr); // slightly larger font for better readability. TODO: more font sizes?
|
||||
} else {
|
||||
_u8g2.setFont(u8g2_font_5x7_mr);
|
||||
}
|
||||
_fontAscent = _u8g2.getAscent();
|
||||
_fontHeight = _u8g2.getAscent() - _u8g2.getDescent();
|
||||
}
|
||||
|
||||
public:
|
||||
U8g2Display() : DisplayDriver(OLED_WIDTH, OLED_HEIGHT),
|
||||
_u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE),
|
||||
_isOn(false), _drawColor(1), _fontAscent(5), _fontHeight(6) {}
|
||||
|
||||
bool begin() {
|
||||
// Wire must already be initialised by board.begin() before this is called
|
||||
bool ok = _u8g2.begin();
|
||||
if (ok) {
|
||||
_u8g2.setI2CAddress(DISPLAY_ADDRESS * 2); // U8g2 uses 8-bit address
|
||||
_u8g2.setFontPosTop(); // y coordinate = top of text, not baseline
|
||||
_u8g2.setFontMode(1); // transparent background
|
||||
applyFont(1); // default to compact font
|
||||
_isOn = true;
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool isOn() override { return _isOn; }
|
||||
|
||||
void turnOn() override {
|
||||
_u8g2.setPowerSave(0);
|
||||
_isOn = true;
|
||||
}
|
||||
|
||||
void turnOff() override {
|
||||
_u8g2.setPowerSave(1);
|
||||
_isOn = false;
|
||||
}
|
||||
|
||||
void clear() override {
|
||||
_u8g2.clearBuffer();
|
||||
_u8g2.sendBuffer();
|
||||
}
|
||||
|
||||
void startFrame(Color bkg = DARK) override {
|
||||
_u8g2.clearBuffer();
|
||||
_drawColor = 1;
|
||||
_u8g2.setDrawColor(1);
|
||||
applyFont(1);
|
||||
}
|
||||
|
||||
void setTextSize(int sz) override {
|
||||
applyFont(sz);
|
||||
}
|
||||
|
||||
void setColor(Color c) override {
|
||||
_drawColor = (c != DARK) ? 1 : 0;
|
||||
_u8g2.setDrawColor(_drawColor);
|
||||
}
|
||||
|
||||
void setCursor(int x, int y) override {
|
||||
_cursorX = x;
|
||||
_cursorY = y;
|
||||
}
|
||||
|
||||
void print(const char* str) override {
|
||||
_u8g2.setDrawColor(_drawColor);
|
||||
_u8g2.drawStr(_cursorX, _cursorY, str);
|
||||
}
|
||||
|
||||
void fillRect(int x, int y, int w, int h) override {
|
||||
_u8g2.setDrawColor(_drawColor);
|
||||
_u8g2.drawBox(x, y, w, h);
|
||||
}
|
||||
|
||||
void drawRect(int x, int y, int w, int h) override {
|
||||
_u8g2.setDrawColor(_drawColor);
|
||||
_u8g2.drawFrame(x, y, w, h);
|
||||
}
|
||||
|
||||
void drawXbm(int x, int y, const uint8_t* bits, int w, int h) override {
|
||||
_u8g2.setDrawColor(1);
|
||||
_u8g2.drawXBM(x, y, w, h, bits);
|
||||
}
|
||||
|
||||
uint16_t getTextWidth(const char* str) override {
|
||||
return _u8g2.getStrWidth(str);
|
||||
}
|
||||
|
||||
void endFrame() override {
|
||||
_u8g2.sendBuffer();
|
||||
}
|
||||
|
||||
private:
|
||||
int _cursorX = 0;
|
||||
int _cursorY = 0;
|
||||
};
|
||||
@@ -1,3 +1,4 @@
|
||||
#include "Arduino.h"
|
||||
#ifdef PIN_BUZZER
|
||||
#include "buzzer.h"
|
||||
|
||||
@@ -12,7 +13,6 @@ void genericBuzzer::begin() {
|
||||
quiet(false);
|
||||
pinMode(PIN_BUZZER, OUTPUT);
|
||||
digitalWrite(PIN_BUZZER, LOW); // need to pull low by default to avoid extreme power draw
|
||||
startup();
|
||||
}
|
||||
|
||||
void genericBuzzer::play(const char *melody) {
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
/* class abstracts underlying RTTTL library
|
||||
|
||||
Just a simple imlementation to start. At the moment use same
|
||||
Just a simple implementation to start. At the moment use same
|
||||
melody for message and discovery
|
||||
Suggest enum type for different sounds
|
||||
- on message
|
||||
|
||||
Reference in new issue
Block a user