346 lines
10 KiB
C++
346 lines
10 KiB
C++
#include "SensorLogger.h"
|
|
|
|
#include <Adafruit_AHTX0.h>
|
|
#include <BH1750.h>
|
|
#include <BLE2902.h>
|
|
#include <BLEDevice.h>
|
|
#include <BLEServer.h>
|
|
#include <BLEUtils.h>
|
|
#include <time.h>
|
|
|
|
namespace {
|
|
constexpr char kNusServiceUuid[] = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E";
|
|
constexpr char kNusRxUuid[] = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E";
|
|
constexpr char kNusTxUuid[] = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E";
|
|
constexpr int64_t kInitialYear = 1700;
|
|
constexpr int64_t kSecondsPerDay = 86400;
|
|
|
|
Adafruit_AHTX0 aht20;
|
|
BH1750 bh1750;
|
|
bool aht20Ready = false;
|
|
bool bh1750Ready = false;
|
|
|
|
bool isLeapYear(int year) {
|
|
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
|
|
}
|
|
}
|
|
|
|
class SensorLoggerCallbacks : public BLECharacteristicCallbacks {
|
|
public:
|
|
explicit SensorLoggerCallbacks(SensorLogger* logger) : logger_(logger) {}
|
|
|
|
void onWrite(BLECharacteristic* characteristic) override {
|
|
logger_->receiveBluetoothData(characteristic->getValue().c_str());
|
|
}
|
|
|
|
private:
|
|
SensorLogger* logger_;
|
|
};
|
|
|
|
class SensorLoggerServerCallbacks : public BLEServerCallbacks {
|
|
public:
|
|
explicit SensorLoggerServerCallbacks(SensorLogger* logger) : logger_(logger) {}
|
|
|
|
void onConnect(BLEServer*) override {
|
|
logger_->bluetoothConnected_ = true;
|
|
}
|
|
|
|
void onDisconnect(BLEServer* server) override {
|
|
logger_->bluetoothConnected_ = false;
|
|
logger_->commandBuffer_ = "";
|
|
logger_->lastAdvertise_ = millis();
|
|
server->startAdvertising();
|
|
}
|
|
|
|
private:
|
|
SensorLogger* logger_;
|
|
};
|
|
|
|
void SensorLogger::begin(uint8_t soilPin) {
|
|
soilPin_ = soilPin;
|
|
pinMode(soilPin_, INPUT);
|
|
analogReadResolution(12);
|
|
|
|
aht20Ready = aht20.begin();
|
|
bh1750Ready = bh1750.begin(BH1750::CONTINUOUS_HIGH_RES_MODE);
|
|
|
|
uint64_t mac = ESP.getEfuseMac();
|
|
char name[14];
|
|
snprintf(name, sizeof(name), "EnvLog-%05llX", mac & 0xFFFFF);
|
|
bluetoothName_ = name;
|
|
BLEDevice::init(bluetoothName_.c_str());
|
|
|
|
server_ = BLEDevice::createServer();
|
|
server_->setCallbacks(new SensorLoggerServerCallbacks(this));
|
|
BLEService* service = server_->createService(kNusServiceUuid);
|
|
BLECharacteristic* rxCharacteristic = service->createCharacteristic(
|
|
kNusRxUuid, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
|
|
rxCharacteristic->setCallbacks(new SensorLoggerCallbacks(this));
|
|
txCharacteristic_ = service->createCharacteristic(
|
|
kNusTxUuid, BLECharacteristic::PROPERTY_NOTIFY);
|
|
txCharacteristic_->addDescriptor(new BLE2902());
|
|
service->start();
|
|
|
|
BLEAdvertising* advertising = BLEDevice::getAdvertising();
|
|
advertising->addServiceUUID(kNusServiceUuid);
|
|
advertising->setScanResponse(true);
|
|
advertising->setMinPreferred(0x06);
|
|
advertising->setMinPreferred(0x12);
|
|
BLEDevice::startAdvertising();
|
|
|
|
readAndStore();
|
|
lastMeasure_ = millis();
|
|
lastAdvertise_ = millis();
|
|
}
|
|
|
|
bool SensorLogger::update() {
|
|
processBluetooth();
|
|
|
|
unsigned long now = millis();
|
|
if (!bluetoothConnected_ && now - lastAdvertise_ >= kAdvertiseRetryIntervalMs) {
|
|
lastAdvertise_ = now;
|
|
BLEDevice::startAdvertising();
|
|
}
|
|
|
|
if (now - lastMeasure_ >= kMeasureIntervalMs) {
|
|
lastMeasure_ = now;
|
|
readAndStore();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SensorLogger::refreshSensors() {
|
|
SensorReading reading = {};
|
|
sensors_event_t humidityEvent;
|
|
sensors_event_t temperatureEvent;
|
|
|
|
if (aht20Ready) {
|
|
aht20.getEvent(&humidityEvent, &temperatureEvent);
|
|
reading.temperature = temperatureEvent.temperature;
|
|
reading.humidity = humidityEvent.relative_humidity;
|
|
}
|
|
if (bh1750Ready) {
|
|
reading.illuminance = bh1750.readLightLevel();
|
|
}
|
|
reading.soilMoisture = analogRead(soilPin_);
|
|
reading.timestamp = latest_.timestamp;
|
|
latest_ = reading;
|
|
}
|
|
|
|
const SensorReading& SensorLogger::latest() const {
|
|
return latest_;
|
|
}
|
|
|
|
bool SensorLogger::hasReading() const {
|
|
return logCount_ != 0;
|
|
}
|
|
|
|
const char* SensorLogger::bluetoothName() const {
|
|
return bluetoothName_.c_str();
|
|
}
|
|
|
|
bool SensorLogger::isBluetoothConnected() const {
|
|
return bluetoothConnected_;
|
|
}
|
|
|
|
size_t SensorLogger::logCount() const {
|
|
return logCount_;
|
|
}
|
|
|
|
bool SensorLogger::formatTimestamp(int64_t timestamp, char* buffer, size_t bufferSize) const {
|
|
if (bufferSize == 0) {
|
|
return false;
|
|
}
|
|
|
|
if (timeSynchronized_) {
|
|
time_t unixTimestamp = static_cast<time_t>(timestamp);
|
|
struct tm date;
|
|
localtime_r(&unixTimestamp, &date);
|
|
strftime(buffer, bufferSize, "%Y/%m/%d %H:%M:%S", &date);
|
|
return true;
|
|
}
|
|
|
|
int year = static_cast<int>(kInitialYear);
|
|
int month = 1;
|
|
int day = 1;
|
|
int64_t days = timestamp / kSecondsPerDay;
|
|
int seconds = static_cast<int>(timestamp % kSecondsPerDay);
|
|
while (days >= (isLeapYear(year) ? 366 : 365)) {
|
|
days -= isLeapYear(year) ? 366 : 365;
|
|
++year;
|
|
}
|
|
const int daysInMonth[] = {
|
|
31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30,
|
|
31, 31, 30, 31, 30, 31
|
|
};
|
|
while (days >= daysInMonth[month - 1]) {
|
|
days -= daysInMonth[month - 1];
|
|
++month;
|
|
}
|
|
day += static_cast<int>(days);
|
|
snprintf(buffer, bufferSize, "%04d/%02d/%02d %02d:%02d:%02d",
|
|
year, month, day, seconds / 3600, (seconds / 60) % 60, seconds % 60);
|
|
return true;
|
|
}
|
|
|
|
bool SensorLogger::getCurrentTime(char* buffer, size_t bufferSize) const {
|
|
return formatTimestamp(currentTimestamp(), buffer, bufferSize);
|
|
}
|
|
|
|
void SensorLogger::readAndStore() {
|
|
sensors_event_t humidityEvent;
|
|
sensors_event_t temperatureEvent;
|
|
SensorReading reading = {};
|
|
|
|
if (aht20Ready) {
|
|
aht20.getEvent(&humidityEvent, &temperatureEvent);
|
|
reading.temperature = temperatureEvent.temperature;
|
|
reading.humidity = humidityEvent.relative_humidity;
|
|
}
|
|
if (bh1750Ready) {
|
|
reading.illuminance = bh1750.readLightLevel();
|
|
}
|
|
reading.soilMoisture = analogRead(soilPin_);
|
|
reading.timestamp = currentTimestamp();
|
|
latest_ = reading;
|
|
|
|
size_t writeIndex = (logStart_ + logCount_) % kMaxLogEntries;
|
|
if (logCount_ == kMaxLogEntries) {
|
|
log_[logStart_] = reading;
|
|
logStart_ = (logStart_ + 1) % kMaxLogEntries;
|
|
} else {
|
|
log_[writeIndex] = reading;
|
|
++logCount_;
|
|
}
|
|
}
|
|
|
|
void SensorLogger::processBluetooth() {
|
|
while (commandBuffer_.indexOf('\n') >= 0 || commandBuffer_.indexOf('\r') >= 0) {
|
|
int lineEnd = commandBuffer_.indexOf('\n');
|
|
int carriageReturn = commandBuffer_.indexOf('\r');
|
|
if (lineEnd < 0 || (carriageReturn >= 0 && carriageReturn < lineEnd)) {
|
|
lineEnd = carriageReturn;
|
|
}
|
|
String command = commandBuffer_.substring(0, lineEnd);
|
|
commandBuffer_.remove(0, lineEnd + 1);
|
|
if (command.length() != 0) {
|
|
processCommand(command);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SensorLogger::receiveBluetoothData(const String& data) {
|
|
for (size_t index = 0; index < data.length(); ++index) {
|
|
char character = data[index];
|
|
if (character == '\n' || character == '\r') {
|
|
commandBuffer_ += character;
|
|
} else if (commandBuffer_.length() < 64) {
|
|
commandBuffer_ += character;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SensorLogger::applyHistoricalTimeAdjustment(int64_t epoch) {
|
|
if (historicalAdjustmentApplied_ || timeSynchronized_) {
|
|
return;
|
|
}
|
|
|
|
const int64_t elapsedSeconds = millis() / 1000UL;
|
|
historicalEpochOffset_ = epoch - elapsedSeconds;
|
|
for (size_t index = 0; index < logCount_; ++index) {
|
|
size_t logIndex = (logStart_ + index) % kMaxLogEntries;
|
|
const int64_t storedSeconds = log_[logIndex].timestamp;
|
|
if (storedSeconds <= elapsedSeconds) {
|
|
log_[logIndex].timestamp = storedSeconds + historicalEpochOffset_;
|
|
}
|
|
}
|
|
historicalAdjustmentApplied_ = true;
|
|
}
|
|
|
|
void SensorLogger::processCommand(const String& command) {
|
|
if (command == "GET_LOG") {
|
|
sendLog();
|
|
} else if (command == "CLEAR_LOG") {
|
|
clearLog();
|
|
txCharacteristic_->setValue("OK_CLEARED\n");
|
|
txCharacteristic_->notify();
|
|
} else if (command.startsWith("TIME:")) {
|
|
unsigned long epoch = command.substring(5).toInt();
|
|
unsigned int year;
|
|
unsigned int month;
|
|
unsigned int day;
|
|
unsigned int hour;
|
|
unsigned int minute;
|
|
unsigned int second;
|
|
if (sscanf(command.c_str(), "TIME:[%u,%u,%u,%u,%u,%u]",
|
|
&year, &month, &day, &hour, &minute, &second) == 6) {
|
|
struct tm date = {};
|
|
date.tm_year = year - 1900;
|
|
date.tm_mon = month - 1;
|
|
date.tm_mday = day;
|
|
date.tm_hour = hour;
|
|
date.tm_min = minute;
|
|
date.tm_sec = second;
|
|
epoch = static_cast<unsigned long>(mktime(&date));
|
|
}
|
|
if (epoch != 0) {
|
|
applyHistoricalTimeAdjustment(static_cast<int64_t>(epoch));
|
|
epochOffset_ = epoch - millis() / 1000UL;
|
|
timeSynchronized_ = true;
|
|
txCharacteristic_->setValue("OK_TIME\n");
|
|
txCharacteristic_->notify();
|
|
} else {
|
|
txCharacteristic_->setValue("ERROR_TIME\n");
|
|
txCharacteristic_->notify();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SensorLogger::sendLog() {
|
|
sendNotification("タイムスタンプ,温度,湿度,土壌水分,光量,デバイス名\n");
|
|
for (size_t index = 0; index < logCount_; ++index) {
|
|
size_t logIndex = (logStart_ + index) % kMaxLogEntries;
|
|
const SensorReading& reading = log_[logIndex];
|
|
char timestamp[32];
|
|
char line[160];
|
|
const bool timestampValid = formatTimestamp(reading.timestamp, timestamp, sizeof(timestamp));
|
|
if (!timestampValid) {
|
|
timestamp[0] = '\0';
|
|
}
|
|
snprintf(line, sizeof(line), "%s,%.2f,%.2f,%u,%.2f,%s\n",
|
|
timestamp,
|
|
reading.temperature,
|
|
reading.humidity,
|
|
reading.soilMoisture,
|
|
reading.illuminance,
|
|
bluetoothName_.c_str());
|
|
sendNotification(line);
|
|
delay(20);
|
|
}
|
|
sendNotification("END_LOG\n");
|
|
}
|
|
|
|
void SensorLogger::sendNotification(const char* data) {
|
|
constexpr size_t kNotificationSize = 20;
|
|
uint8_t notification[kNotificationSize];
|
|
size_t length = strlen(data);
|
|
for (size_t offset = 0; offset < length; offset += kNotificationSize) {
|
|
size_t chunkSize = min(kNotificationSize, length - offset);
|
|
memcpy(notification, data + offset, chunkSize);
|
|
txCharacteristic_->setValue(notification, chunkSize);
|
|
txCharacteristic_->notify();
|
|
delay(10);
|
|
}
|
|
}
|
|
|
|
void SensorLogger::clearLog() {
|
|
logStart_ = 0;
|
|
logCount_ = 0;
|
|
}
|
|
|
|
int64_t SensorLogger::currentTimestamp() const {
|
|
int64_t elapsedSeconds = millis() / 1000UL;
|
|
return timeSynchronized_ ? epochOffset_ + elapsedSeconds : elapsedSeconds;
|
|
}
|