316 lines
9.4 KiB
C++
316 lines
9.4 KiB
C++
#include "Nuki.h"
|
|
#include <FreeRTOS.h>
|
|
#include "PreferencesKeys.h"
|
|
|
|
Nuki* nukiInst;
|
|
|
|
Nuki::Nuki(const std::string& name, uint32_t id, Network* network, Preferences* preferences)
|
|
: _nukiBle(name, id),
|
|
_network(network),
|
|
_preferences(preferences)
|
|
{
|
|
nukiInst = this;
|
|
|
|
memset(&_lastKeyTurnerState, sizeof(KeyTurnerState), 0);
|
|
memset(&_keyTurnerState, sizeof(KeyTurnerState), 0);
|
|
memset(&_lastBatteryReport, sizeof(BatteryReport), 0);
|
|
memset(&_batteryReport, sizeof(BatteryReport), 0);
|
|
|
|
network->setLockActionReceived(nukiInst->onLockActionReceived);
|
|
}
|
|
|
|
void Nuki::initialize()
|
|
{
|
|
_bleScanner.initialize();
|
|
_nukiBle.initialize();
|
|
_nukiBle.registerBleScanner(&_bleScanner);
|
|
|
|
_intervalLockstate = _preferences->getInt(preference_query_interval_lockstate);
|
|
_intervalBattery = _preferences->getInt(preference_query_interval_battery);
|
|
|
|
if(_intervalLockstate == 0)
|
|
{
|
|
_intervalLockstate = 30;
|
|
_preferences->putInt(preference_query_interval_lockstate, _intervalLockstate);
|
|
}
|
|
if(_intervalBattery == 0)
|
|
{
|
|
_intervalBattery = 60 * 30;
|
|
_preferences->putInt(preference_query_interval_battery, _intervalBattery);
|
|
}
|
|
|
|
_nukiBle.setEventHandler(this);
|
|
|
|
Serial.print(F("Lock state interval: "));
|
|
Serial.print(_intervalLockstate);
|
|
Serial.print(F("| Battery interval: "));
|
|
Serial.println(_intervalBattery);
|
|
}
|
|
|
|
void Nuki::update()
|
|
{
|
|
if (!_paired) {
|
|
Serial.println(F("Nuki start pairing"));
|
|
|
|
if (_nukiBle.pairNuki()) {
|
|
Serial.println(F("Nuki paired"));
|
|
_paired = true;
|
|
}
|
|
else
|
|
{
|
|
vTaskDelay( 200 / portTICK_PERIOD_MS);
|
|
return;
|
|
}
|
|
}
|
|
|
|
vTaskDelay( 20 / portTICK_PERIOD_MS);
|
|
_bleScanner.update();
|
|
|
|
unsigned long ts = millis();
|
|
|
|
if(_statusUpdated || _nextLockStateUpdateTs == 0 || ts >= _nextLockStateUpdateTs)
|
|
{
|
|
_statusUpdated = false;
|
|
_nextLockStateUpdateTs = ts + _intervalLockstate * 1000;
|
|
updateKeyTurnerState();
|
|
}
|
|
if(_nextBatteryReportTs == 0 || ts > _nextBatteryReportTs)
|
|
{
|
|
_nextBatteryReportTs = ts + _intervalBattery * 1000;
|
|
updateBatteryState();
|
|
}
|
|
if(_nextLockAction != (LockAction)0xff)
|
|
{
|
|
_nukiBle.lockAction(_nextLockAction, 0, 0);
|
|
_nextLockAction = (LockAction)0xff;
|
|
}
|
|
}
|
|
|
|
void Nuki::updateKeyTurnerState()
|
|
{
|
|
_nukiBle.requestKeyTurnerState(&_keyTurnerState);
|
|
|
|
if(_keyTurnerState.lockState != _lastKeyTurnerState.lockState)
|
|
{
|
|
char lockStateStr[20];
|
|
lockstateToString(_keyTurnerState.lockState, lockStateStr);
|
|
char triggerStr[20];
|
|
triggerToString(_keyTurnerState.trigger, triggerStr);
|
|
char completionStatusStr[20];
|
|
completionStatusToString(_keyTurnerState.lastLockActionCompletionStatus, completionStatusStr);
|
|
|
|
_network->publishKeyTurnerState(lockStateStr, triggerStr, completionStatusStr);
|
|
Serial.print(F("Nuki lock state: "));
|
|
Serial.println(lockStateStr);
|
|
}
|
|
|
|
if(_keyTurnerState.doorSensorState != _lastKeyTurnerState.doorSensorState)
|
|
{
|
|
char doorSensorStateStr[20];
|
|
doorSensorStateToString(_keyTurnerState.doorSensorState, doorSensorStateStr);
|
|
_network->publishDoorSensorState(doorSensorStateStr);
|
|
}
|
|
|
|
if(_keyTurnerState.criticalBatteryState != _lastKeyTurnerState.criticalBatteryState)
|
|
{
|
|
uint8_t level = (_keyTurnerState.criticalBatteryState & 0b11111100) >> 1;
|
|
bool critical = (_keyTurnerState.criticalBatteryState & 0b00000001) > 0;
|
|
bool charging = (_keyTurnerState.criticalBatteryState & 0b00000010) > 0;
|
|
_network->publishCriticalBattery(level, critical, charging);
|
|
}
|
|
|
|
memcpy(&_lastKeyTurnerState, &_keyTurnerState, sizeof(KeyTurnerState));
|
|
}
|
|
|
|
|
|
void Nuki::updateBatteryState()
|
|
{
|
|
_nukiBle.requestBatteryReport(&_batteryReport);
|
|
|
|
Serial.print(F("Voltage: ")); Serial.println(_batteryReport.batteryVoltage);
|
|
Serial.print(F("Drain: ")); Serial.println(_batteryReport.batteryDrain);
|
|
Serial.print(F("Resistance: ")); Serial.println(_batteryReport.batteryResistance);
|
|
Serial.print(F("Max Current: ")); Serial.println(_batteryReport.maxTurnCurrent);
|
|
Serial.print(F("Crit. State: ")); Serial.println(_batteryReport.criticalBatteryState);
|
|
Serial.print(F("Lock Dist: ")); Serial.println(_batteryReport.lockDistance);
|
|
|
|
_network->publishBatteryReport(_batteryReport);
|
|
}
|
|
|
|
|
|
void Nuki::lockstateToString(const LockState state, char* str)
|
|
{
|
|
switch(state)
|
|
{
|
|
case LockState::uncalibrated:
|
|
strcpy(str, "uncalibrated");
|
|
break;
|
|
case LockState::locked:
|
|
strcpy(str, "locked");
|
|
break;
|
|
case LockState::locking:
|
|
strcpy(str, "locking");
|
|
break;
|
|
case LockState::unlocked:
|
|
strcpy(str, "unlocked");
|
|
break;
|
|
case LockState::unlatched:
|
|
strcpy(str, "unlatched");
|
|
break;
|
|
case LockState::unlockedLnga:
|
|
strcpy(str, "unlockedLnga");
|
|
break;
|
|
case LockState::unlatching:
|
|
strcpy(str, "unlatching");
|
|
break;
|
|
case LockState::calibration:
|
|
strcpy(str, "calibration");
|
|
break;
|
|
case LockState::bootRun:
|
|
strcpy(str, "bootRun");
|
|
break;
|
|
case LockState::motorBlocked:
|
|
strcpy(str, "motorBlocked");
|
|
break;
|
|
default:
|
|
strcpy(str, "undefined");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void Nuki::triggerToString(const NukiTrigger trigger, char *str)
|
|
{
|
|
switch(trigger)
|
|
{
|
|
case NukiTrigger::autoLock:
|
|
strcpy(str, "autoLock");
|
|
break;
|
|
case NukiTrigger::automatic:
|
|
strcpy(str, "automatic");
|
|
break;
|
|
case NukiTrigger::button:
|
|
strcpy(str, "button");
|
|
break;
|
|
case NukiTrigger::manual:
|
|
strcpy(str, "manual");
|
|
break;
|
|
case NukiTrigger::system:
|
|
strcpy(str, "system");
|
|
break;
|
|
default:
|
|
strcpy(str, "undefined");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Nuki::completionStatusToString(const CompletionStatus status, char *str)
|
|
{
|
|
switch (status)
|
|
{
|
|
case CompletionStatus::success:
|
|
strcpy(str, "success");
|
|
break;
|
|
case CompletionStatus::busy:
|
|
strcpy(str, "busy");
|
|
break;
|
|
case CompletionStatus::canceled:
|
|
strcpy(str, "canceled");
|
|
break;
|
|
case CompletionStatus::clutchFailure:
|
|
strcpy(str, "clutchFailure");
|
|
break;
|
|
case CompletionStatus::incompleteFailure:
|
|
strcpy(str, "incompleteFailure");
|
|
break;
|
|
case CompletionStatus::invalidCode:
|
|
strcpy(str, "invalidCode");
|
|
break;
|
|
case CompletionStatus::lowMotorVoltage:
|
|
strcpy(str, "lowMotorVoltage");
|
|
break;
|
|
case CompletionStatus::motorBlocked:
|
|
strcpy(str, "motorBlocked");
|
|
break;
|
|
case CompletionStatus::motorPowerFailure:
|
|
strcpy(str, "motorPowerFailure");
|
|
break;
|
|
case CompletionStatus::otherError:
|
|
strcpy(str, "otherError");
|
|
break;
|
|
case CompletionStatus::tooRecent:
|
|
strcpy(str, "tooRecent");
|
|
break;
|
|
case CompletionStatus::unknown:
|
|
strcpy(str, "unknown");
|
|
break;
|
|
default:
|
|
strcpy(str, "undefined");
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void Nuki::doorSensorStateToString(const DoorSensorState state, char *str)
|
|
{
|
|
switch(state)
|
|
{
|
|
case DoorSensorState::unavailable:
|
|
strcpy(str, "unavailable");
|
|
break;
|
|
case DoorSensorState::deactivated:
|
|
strcpy(str, "deactivated");
|
|
break;
|
|
case DoorSensorState::doorClosed:
|
|
strcpy(str, "doorClosed");
|
|
break;
|
|
case DoorSensorState::doorOpened:
|
|
strcpy(str, "doorOpened");
|
|
break;
|
|
case DoorSensorState::doorStateUnknown:
|
|
strcpy(str, "doorStateUnknown");
|
|
break;
|
|
case DoorSensorState::calibrating:
|
|
strcpy(str, "calibrating");
|
|
break;
|
|
default:
|
|
strcpy(str, "undefined");
|
|
break;
|
|
}
|
|
}
|
|
|
|
LockAction Nuki::lockActionToEnum(const char *str)
|
|
{
|
|
if(strcmp(str, "unlock") == 0) return LockAction::unlock;
|
|
else if(strcmp(str, "lock") == 0) return LockAction::lock;
|
|
else if(strcmp(str, "unlatch") == 0) return LockAction::unlatch;
|
|
else if(strcmp(str, "lockNgo") == 0) return LockAction::lockNgo;
|
|
else if(strcmp(str, "lockNgoUnlatch") == 0) return LockAction::lockNgoUnlatch;
|
|
else if(strcmp(str, "fullLock") == 0) return LockAction::fullLock;
|
|
else if(strcmp(str, "fobAction2") == 0) return LockAction::fobAction2;
|
|
else if(strcmp(str, "fobAction1") == 0) return LockAction::fobAction1;
|
|
else if(strcmp(str, "fobAction3") == 0) return LockAction::fobAction3;
|
|
return (LockAction)0xff;
|
|
}
|
|
|
|
void Nuki::onLockActionReceived(const char *value)
|
|
{
|
|
nukiInst->_nextLockAction = nukiInst->lockActionToEnum(value);
|
|
Serial.print(F("Action: "));
|
|
Serial.println((int)nukiInst->_nextLockAction);
|
|
}
|
|
|
|
const bool Nuki::isPaired()
|
|
{
|
|
return _paired;
|
|
}
|
|
|
|
void Nuki::notify(NukiEventType eventType)
|
|
{
|
|
if(eventType == NukiEventType::KeyTurnerStatusUpdated)
|
|
{
|
|
// Serial.println("SUP2");
|
|
_statusUpdated = true;
|
|
}
|
|
}
|