mirror of
https://github.com/meshcore-dev/MeshCore.git
synced 2026-04-20 22:13:47 +00:00
Merge branch 'dev' into dev
This commit is contained in:
Dale Ruane
GitHub
commit
c9f08e55cb
97 changed files with 3927 additions and 141 deletions
|
|
@ -17,6 +17,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
|
||||
|
||||
|
|
@ -100,4 +101,4 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,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);
|
||||
|
|
@ -25,22 +30,32 @@ void AutoDiscoverRTCClock::begin(TwoWire& wire) {
|
|||
if (i2c_probe(wire, DS3231_ADDRESS)) {
|
||||
ds3231_success = rtc_3231.begin(&wire);
|
||||
}
|
||||
|
||||
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 +66,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 +88,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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -353,8 +353,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 +373,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 +481,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
|
||||
|
|
|
|||
|
|
@ -111,6 +111,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 +150,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);
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
|
|||
file.read((uint8_t *)&_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm)); // 76
|
||||
file.read((uint8_t *)&_prefs->disable_fwd, sizeof(_prefs->disable_fwd)); // 77
|
||||
file.read((uint8_t *)&_prefs->advert_interval, sizeof(_prefs->advert_interval)); // 78
|
||||
file.read((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain)); // 79
|
||||
file.read(pad, 1); // 79 : 1 byte unused (was rx_boosted_gain in v1.14.1, moved to end for upgrade compat)
|
||||
file.read((uint8_t *)&_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base)); // 80
|
||||
file.read((uint8_t *)&_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor)); // 84
|
||||
file.read((uint8_t *)&_prefs->guest_password[0], sizeof(_prefs->guest_password)); // 88
|
||||
|
|
@ -90,13 +90,15 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
|
|||
file.read((uint8_t *)&_prefs->region_autotag, sizeof(_prefs->region_autotag)); // 290
|
||||
file.read((uint8_t *)&_prefs->region_autotag_max_hops, sizeof(_prefs->region_autotag_max_hops)); // 291
|
||||
// next: 292
|
||||
file.read((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain)); // 290
|
||||
// next: 291
|
||||
|
||||
// sanitise bad pref values
|
||||
_prefs->rx_delay_base = constrain(_prefs->rx_delay_base, 0, 20.0f);
|
||||
_prefs->tx_delay_factor = constrain(_prefs->tx_delay_factor, 0, 2.0f);
|
||||
_prefs->direct_tx_delay_factor = constrain(_prefs->direct_tx_delay_factor, 0, 2.0f);
|
||||
_prefs->airtime_factor = constrain(_prefs->airtime_factor, 0, 9.0f);
|
||||
_prefs->freq = constrain(_prefs->freq, 400.0f, 2500.0f);
|
||||
_prefs->freq = constrain(_prefs->freq, 150.0f, 2500.0f);
|
||||
_prefs->bw = constrain(_prefs->bw, 7.8f, 500.0f);
|
||||
_prefs->sf = constrain(_prefs->sf, 5, 12);
|
||||
_prefs->cr = constrain(_prefs->cr, 5, 8);
|
||||
|
|
@ -149,7 +151,7 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
|
|||
file.write((uint8_t *)&_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm)); // 76
|
||||
file.write((uint8_t *)&_prefs->disable_fwd, sizeof(_prefs->disable_fwd)); // 77
|
||||
file.write((uint8_t *)&_prefs->advert_interval, sizeof(_prefs->advert_interval)); // 78
|
||||
file.write((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain)); // 79
|
||||
file.write(pad, 1); // 79 : 1 byte unused (rx_boosted_gain moved to end)
|
||||
file.write((uint8_t *)&_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base)); // 80
|
||||
file.write((uint8_t *)&_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor)); // 84
|
||||
file.write((uint8_t *)&_prefs->guest_password[0], sizeof(_prefs->guest_password)); // 88
|
||||
|
|
@ -184,6 +186,8 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
|
|||
file.write((uint8_t *)&_prefs->region_autotag, sizeof(_prefs->region_autotag)); // 290
|
||||
file.write((uint8_t *)&_prefs->region_autotag_max_hops, sizeof(_prefs->region_autotag_max_hops)); // 291
|
||||
// next: 292
|
||||
file.write((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain)); // 290
|
||||
// next: 291
|
||||
|
||||
file.close();
|
||||
}
|
||||
|
|
@ -279,7 +283,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
uint8_t sf = num > 2 ? atoi(parts[2]) : 0;
|
||||
uint8_t cr = num > 3 ? atoi(parts[3]) : 0;
|
||||
int temp_timeout_mins = num > 4 ? atoi(parts[4]) : 0;
|
||||
if (freq >= 300.0f && freq <= 2500.0f && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7.0f && bw <= 500.0f && temp_timeout_mins > 0) {
|
||||
if (freq >= 150.0f && freq <= 2500.0f && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7.0f && bw <= 500.0f && temp_timeout_mins > 0) {
|
||||
_callbacks->applyTempRadioParams(freq, bw, sf, cr, temp_timeout_mins);
|
||||
sprintf(reply, "OK - temp params for %d mins", temp_timeout_mins);
|
||||
} else {
|
||||
|
|
@ -298,7 +302,12 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
*/
|
||||
} else if (memcmp(command, "get ", 4) == 0) {
|
||||
const char* config = &command[4];
|
||||
if (memcmp(config, "af", 2) == 0) {
|
||||
if (memcmp(config, "dutycycle", 9) == 0) {
|
||||
float dc = 100.0f / (_prefs->airtime_factor + 1.0f);
|
||||
int dc_int = (int)dc;
|
||||
int dc_frac = (int)((dc - dc_int) * 10.0f + 0.5f);
|
||||
sprintf(reply, "> %d.%d%%", dc_int, dc_frac);
|
||||
} else if (memcmp(config, "af", 2) == 0) {
|
||||
sprintf(reply, "> %s", StrHelper::ftoa(_prefs->airtime_factor));
|
||||
} else if (memcmp(config, "int.thresh", 10) == 0) {
|
||||
sprintf(reply, "> %d", (uint32_t) _prefs->interference_threshold);
|
||||
|
|
@ -459,7 +468,19 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
*/
|
||||
} else if (memcmp(command, "set ", 4) == 0) {
|
||||
const char* config = &command[4];
|
||||
if (memcmp(config, "af ", 3) == 0) {
|
||||
if (memcmp(config, "dutycycle ", 10) == 0) {
|
||||
float dc = atof(&config[10]);
|
||||
if (dc < 1 || dc > 100) {
|
||||
strcpy(reply, "ERROR: dutycycle must be 1-100");
|
||||
} else {
|
||||
_prefs->airtime_factor = (100.0f / dc) - 1.0f;
|
||||
savePrefs();
|
||||
float actual = 100.0f / (_prefs->airtime_factor + 1.0f);
|
||||
int a_int = (int)actual;
|
||||
int a_frac = (int)((actual - a_int) * 10.0f + 0.5f);
|
||||
sprintf(reply, "OK - %d.%d%%", a_int, a_frac);
|
||||
}
|
||||
} else if (memcmp(config, "af ", 3) == 0) {
|
||||
_prefs->airtime_factor = atof(&config[3]);
|
||||
savePrefs();
|
||||
strcpy(reply, "OK");
|
||||
|
|
@ -543,7 +564,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
float bw = num > 1 ? strtof(parts[1], nullptr) : 0.0f;
|
||||
uint8_t sf = num > 2 ? atoi(parts[2]) : 0;
|
||||
uint8_t cr = num > 3 ? atoi(parts[3]) : 0;
|
||||
if (freq >= 300.0f && freq <= 2500.0f && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7.0f && bw <= 500.0f) {
|
||||
if (freq >= 150.0f && freq <= 2500.0f && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7.0f && bw <= 500.0f) {
|
||||
_prefs->sf = sf;
|
||||
_prefs->cr = cr;
|
||||
_prefs->freq = freq;
|
||||
|
|
@ -741,7 +762,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
}
|
||||
} else if (memcmp(command, "sensor set ", 11) == 0) {
|
||||
strcpy(tmp, &command[11]);
|
||||
const char *parts[2];
|
||||
const char *parts[2];
|
||||
int num = mesh::Utils::parseTextParts(tmp, parts, 2, ' ');
|
||||
const char *key = (num > 0) ? parts[0] : "";
|
||||
const char *value = (num > 1) ? parts[1] : "null";
|
||||
|
|
@ -764,7 +785,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
dp = strchr(dp, 0);
|
||||
int i;
|
||||
for (i = start; i < end && (dp-reply < 134); i++) {
|
||||
sprintf(dp, "%s=%s\n",
|
||||
sprintf(dp, "%s=%s\n",
|
||||
_sensors->getSettingName(i),
|
||||
_sensors->getSettingValue(i));
|
||||
dp = strchr(dp, 0);
|
||||
|
|
@ -844,8 +865,8 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
|
|||
bool active = !strcmp(_sensors->getSettingByKey("gps"), "1");
|
||||
if (enabled) {
|
||||
sprintf(reply, "on, %s, %s, %d sats",
|
||||
active?"active":"deactivated",
|
||||
fix?"fix":"no fix",
|
||||
active?"active":"deactivated",
|
||||
fix?"fix":"no fix",
|
||||
sats);
|
||||
} else {
|
||||
strcpy(reply, "off");
|
||||
|
|
|
|||
|
|
@ -3,6 +3,10 @@
|
|||
#include <MeshCore.h>
|
||||
#include <Arduino.h>
|
||||
|
||||
#ifndef USER_BTN_PRESSED
|
||||
#define USER_BTN_PRESSED LOW
|
||||
#endif
|
||||
|
||||
#if defined(ESP_PLATFORM)
|
||||
|
||||
#include <rom/rtc.h>
|
||||
|
|
|
|||
197
src/helpers/RTC_RX8130CE.cpp
Normal file
197
src/helpers/RTC_RX8130CE.cpp
Normal file
|
|
@ -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;
|
||||
}
|
||||
33
src/helpers/RTC_RX8130CE.h
Normal file
33
src/helpers/RTC_RX8130CE.h
Normal file
|
|
@ -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
|
||||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -4,10 +4,10 @@
|
|||
|
||||
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; }
|
||||
|
||||
void init();
|
||||
int recvRaw(uint8_t* bytes, int sz) override;
|
||||
|
|
@ -19,12 +19,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);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
#endif
|
||||
#define TELEM_BME680_SEALEVELPRESSURE_HPA (1013.25)
|
||||
#include <Adafruit_BME680.h>
|
||||
static Adafruit_BME680 BME680;
|
||||
static Adafruit_BME680 BME680(TELEM_WIRE);
|
||||
#endif
|
||||
|
||||
#ifdef ENV_INCLUDE_BMP085
|
||||
|
|
@ -62,9 +62,15 @@ LPS22HBClass LPS22HB(*TELEM_WIRE);
|
|||
#endif
|
||||
|
||||
#if ENV_INCLUDE_INA3221
|
||||
#ifndef TELEM_INA3221_ADDRESS
|
||||
#define TELEM_INA3221_ADDRESS 0x42 // INA3221 3 channel current sensor I2C address
|
||||
#endif
|
||||
#ifndef TELEM_INA3221_SHUNT_VALUE
|
||||
#define TELEM_INA3221_SHUNT_VALUE 0.100 // most variants will have a 0.1 ohm shunts
|
||||
#endif
|
||||
#ifndef TELEM_INA3221_NUM_CHANNELS
|
||||
#define TELEM_INA3221_NUM_CHANNELS 3
|
||||
#endif
|
||||
#include <Adafruit_INA3221.h>
|
||||
static Adafruit_INA3221 INA3221;
|
||||
#endif
|
||||
|
|
@ -101,6 +107,12 @@ static Adafruit_MLX90614 MLX90614;
|
|||
static Adafruit_VL53L0X VL53L0X;
|
||||
#endif
|
||||
|
||||
#if ENV_INCLUDE_RAK12035
|
||||
#define TELEM_RAK12035_ADDRESS 0x20 // RAK12035 Soil Moisture sensor I2C address
|
||||
#include "RAK12035_SoilMoisture.h"
|
||||
static RAK12035_SoilMoisture RAK12035;
|
||||
#endif
|
||||
|
||||
#if ENV_INCLUDE_GPS && defined(RAK_BOARD) && !defined(RAK_WISMESH_TAG)
|
||||
#define RAK_WISBLOCK_GPS
|
||||
#endif
|
||||
|
|
@ -180,7 +192,7 @@ bool EnvironmentSensorManager::begin() {
|
|||
#endif
|
||||
|
||||
#if ENV_INCLUDE_BME680
|
||||
if (BME680.begin(TELEM_BME680_ADDRESS, TELEM_WIRE)) {
|
||||
if (BME680.begin(TELEM_BME680_ADDRESS)) {
|
||||
MESH_DEBUG_PRINTLN("Found BME680 at address: %02X", TELEM_BME680_ADDRESS);
|
||||
BME680_initialized = true;
|
||||
} else {
|
||||
|
|
@ -331,6 +343,17 @@ bool EnvironmentSensorManager::begin() {
|
|||
}
|
||||
#endif
|
||||
|
||||
#if ENV_INCLUDE_RAK12035
|
||||
RAK12035.setup(*TELEM_WIRE);
|
||||
if (RAK12035.begin(TELEM_RAK12035_ADDRESS)) {
|
||||
MESH_DEBUG_PRINTLN("Found sensor RAK12035 at address: %02X", TELEM_RAK12035_ADDRESS);
|
||||
RAK12035_initialized = true;
|
||||
} else {
|
||||
RAK12035_initialized = false;
|
||||
MESH_DEBUG_PRINTLN("RAK12035 was not found at I2C address %02X", TELEM_RAK12035_ADDRESS);
|
||||
}
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -483,8 +506,36 @@ bool EnvironmentSensorManager::querySensors(uint8_t requester_permissions, Cayen
|
|||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
#if ENV_INCLUDE_RAK12035
|
||||
if (RAK12035_initialized) {
|
||||
|
||||
// RAK12035 Telemetry is Channel 2
|
||||
telemetry.addTemperature(2, RAK12035.get_sensor_temperature());
|
||||
telemetry.addPercentage(2, RAK12035.get_sensor_moisture());
|
||||
|
||||
// RAK12035 CALIBRATION Telemetry is Channel 3, if enabled
|
||||
|
||||
#ifdef ENABLE_RAK12035_CALIBRATION
|
||||
// Calibration Data Screen is Channel 3
|
||||
float cap = RAK12035.get_sensor_capacitance();
|
||||
float _wet = RAK12035.get_humidity_full();
|
||||
float _dry = RAK12035.get_humidity_zero();
|
||||
|
||||
telemetry.addFrequency(3, cap);
|
||||
telemetry.addTemperature(3, _wet);
|
||||
telemetry.addPower(3, _dry);
|
||||
|
||||
if(cap > _dry){
|
||||
RAK12035.set_humidity_zero(cap);
|
||||
}
|
||||
|
||||
if(cap < _wet){
|
||||
RAK12035.set_humidity_full(cap);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -665,7 +716,7 @@ bool EnvironmentSensorManager::gpsIsAwake(uint8_t ioPin){
|
|||
gps_detected = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
pinMode(ioPin, INPUT);
|
||||
MESH_DEBUG_PRINTLN("GPS did not init with this IO pin... try the next");
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ protected:
|
|||
bool SHT4X_initialized = false;
|
||||
bool BME680_initialized = false;
|
||||
bool BMP085_initialized = false;
|
||||
bool RAK12035_initialized = false;
|
||||
|
||||
bool gps_detected = false;
|
||||
bool gps_active = false;
|
||||
|
|
|
|||
554
src/helpers/sensors/RAK12035_SoilMoisture.cpp
Normal file
554
src/helpers/sensors/RAK12035_SoilMoisture.cpp
Normal file
|
|
@ -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 supprt three sensors ***
|
||||
// The RAK12023 has three connectors, but each of the sensors attached must
|
||||
// all have a different I2C addresses.
|
||||
// This code has a function to set the I2C adress 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: varients/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 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 funstion 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 telemerty 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 funstion 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;
|
||||
time_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 funstion 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;
|
||||
}
|
||||
88
src/helpers/sensors/RAK12035_SoilMoisture.h
Normal file
88
src/helpers/sensors/RAK12035_SoilMoisture.h
Normal file
|
|
@ -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
|
||||
|
|
@ -21,10 +21,14 @@ 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_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 +54,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();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue