Sternenlabor/nuki_hub
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add opener code

Browse Source
This commit is contained in:
technyon
2022-05-29 23:23:27 +02:00
parent 62bf4191b2
commit 875dc34012
8 changed files with 440 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -29,6 +29,7 @@ file(GLOB SRCFILES
networkDevices/WifiDevice.cpp
networkDevices/W5500Device.cpp
NukiWrapper.cpp
NukiOpenerWrapper.cpp
MqttTopics.h
WebCfgServer.cpp
PresenceDetection.cpp

19
Network.cpp
View File

@@ -74,7 +74,7 @@ void Network::initialize()
_preferences->putInt(preference_mqtt_broker_port, port);
}
String mqttPath = _preferences->getString(preference_mqtt_path);
String mqttPath = _preferences->getString(preference_mqtt_lock_path);
if(mqttPath.length() > 0)
{
size_t len = mqttPath.length();
@@ -86,7 +86,22 @@ void Network::initialize()
else
{
strcpy(_mqttPath, "nuki");
_preferences->putString(preference_mqtt_path, _mqttPath);
_preferences->putString(preference_mqtt_lock_path, _mqttPath);
}
String mqttOpenerPath = _preferences->getString(preference_mqtt_opener_path);
if(mqttOpenerPath.length() > 0)
{
size_t len = mqttOpenerPath.length();
for(int i=0; i < len; i++)
{
_mqttOpenerPath[i] = mqttOpenerPath.charAt(i);
}
}
else
{
strcpy(_mqttOpenerPath, "nukiopener");
_preferences->putString(preference_mqtt_opener_path, _mqttOpenerPath);
}
String mqttUser = _preferences->getString(preference_mqtt_user);

1
Network.h
View File

@@ -67,6 +67,7 @@ private:
unsigned long _nextReconnect = 0;
char _mqttBrokerAddr[101] = {0};
char _mqttPath[181] = {0};
char _mqttOpenerPath[181] = {0};
char _mqttUser[31] = {0};
char _mqttPass[31] = {0};
int _networkTimeout = 0;

333
NukiOpenerWrapper.cpp Normal file
View File

@@ -0,0 +1,333 @@
#include "NukiOpenerWrapper.h"
#include <FreeRTOS.h>
#include "PreferencesKeys.h"
#include "MqttTopics.h"
#include <NukiOpenerUtils.h>
NukiOpenerWrapper* nukiOpenerInst;
NukiOpenerWrapper::NukiOpenerWrapper(const std::string& deviceName, uint32_t id, Network* network, Preferences* preferences)
: _deviceName(deviceName),
_nukiBle(deviceName, id),
_network(network),
_preferences(preferences)
{
nukiOpenerInst = this;
memset(&_lastKeyTurnerState, sizeof(NukiLock::KeyTurnerState), 0);
memset(&_lastBatteryReport, sizeof(NukiLock::BatteryReport), 0);
memset(&_batteryReport, sizeof(NukiLock::BatteryReport), 0);
memset(&_keyTurnerState, sizeof(NukiLock::KeyTurnerState), 0);
_keyTurnerState.lockState = NukiOpener::LockState::Undefined;
network->setLockActionReceivedCallback(nukiOpenerInst->onLockActionReceivedCallback);
network->setConfigUpdateReceivedCallback(nukiOpenerInst->onConfigUpdateReceivedCallback);
}
NukiOpenerWrapper::~NukiOpenerWrapper()
{
delete _bleScanner;
_bleScanner = nullptr;
}
void NukiOpenerWrapper::initialize()
{
_bleScanner = new BleScanner::Scanner();
_bleScanner->initialize(_deviceName);
_bleScanner->setScanDuration(10);
_nukiBle.initialize();
_nukiBle.registerBleScanner(_bleScanner);
_intervalLockstate = _preferences->getInt(preference_query_interval_lockstate);
_intervalBattery = _preferences->getInt(preference_query_interval_battery);
_publishAuthData = _preferences->getBool(preference_publish_authdata);
if(_intervalLockstate == 0)
{
_intervalLockstate = 60 * 5;
_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.print(_intervalBattery);
Serial.print(F(" | Publish auth data: "));
Serial.println(_publishAuthData ? "yes" : "no");
if(!_publishAuthData)
{
_clearAuthData = true;
}
}
void NukiOpenerWrapper::update()
{
if (!_paired) {
Serial.println(F("Nuki start pairing"));
_bleScanner->update();
vTaskDelay( 5000 / portTICK_PERIOD_MS);
if (_nukiBle.pairNuki() == NukiOpener::PairingResult::Success) {
Serial.println(F("Nuki paired"));
_paired = true;
}
else
{
vTaskDelay( 200 / portTICK_PERIOD_MS);
return;
}
}
vTaskDelay( 20 / portTICK_PERIOD_MS);
_bleScanner->update();
_nukiBle.updateConnectionState();
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(_nextConfigUpdateTs == 0 || ts > _nextConfigUpdateTs)
{
_nextConfigUpdateTs = ts + _intervalConfig * 1000;
updateConfig();
}
if(_nextLockAction != (NukiOpener::LockAction)0xff)
{
NukiOpener::CmdResult cmdResult = _nukiBle.lockAction(_nextLockAction, 0, 0);
char resultStr[15] = {0};
NukiOpener::cmdResultToString(cmdResult, resultStr);
_network->publishCommandResult(resultStr);
Serial.print(F("Lock action result: "));
Serial.println(resultStr);
_nextLockAction = (NukiOpener::LockAction)0xff;
if(_intervalLockstate > 10)
{
_nextLockStateUpdateTs = ts + 10 * 1000;
}
}
if(_clearAuthData)
{
_network->publishAuthorizationInfo(0, "");
_clearAuthData = false;
}
memcpy(&_lastKeyTurnerState, &_keyTurnerState, sizeof(NukiLock::KeyTurnerState));
}
void NukiOpenerWrapper::setPin(const uint16_t pin)
{
_nukiBle.saveSecurityPincode(pin);
}
void NukiOpenerWrapper::unpair()
{
_nukiBle.unPairNuki();
_paired = false;
}
void NukiOpenerWrapper::updateKeyTurnerState()
{
_nukiBle.requestKeyTurnerState(&_keyTurnerState);
// _network->publishKeyTurnerState(_keyTurnerState, _lastKeyTurnerState);
if(_keyTurnerState.lockState != _lastKeyTurnerState.lockState)
{
char lockStateStr[20];
lockstateToString(_keyTurnerState.lockState, lockStateStr);
Serial.print(F("Nuki lock state: "));
Serial.println(lockStateStr);
}
if(_publishAuthData)
{
updateAuthData();
}
}
void NukiOpenerWrapper::updateBatteryState()
{
_nukiBle.requestBatteryReport(&_batteryReport);
// _network->publishBatteryReport(_batteryReport);
}
void NukiOpenerWrapper::updateConfig()
{
readConfig();
readAdvancedConfig();
// _network->publishConfig(_nukiConfig);
// _network->publishAdvancedConfig(_nukiAdvancedConfig);
}
void NukiOpenerWrapper::updateAuthData()
{
Nuki::CmdResult result = _nukiBle.retrieveLogEntries(0, 0, 0, true);
if(result != Nuki::CmdResult::Success)
{
_network->publishAuthorizationInfo(0, "");
return;
}
vTaskDelay( 100 / portTICK_PERIOD_MS);
result = _nukiBle.retrieveLogEntries(_nukiBle.getLogEntryCount() - 2, 1, 0, false);
if(result != Nuki::CmdResult::Success)
{
_network->publishAuthorizationInfo(0, "");
return;
}
vTaskDelay( 200 / portTICK_PERIOD_MS);
std::list<NukiOpener::LogEntry> log;
_nukiBle.getLogEntries(&log);
if(log.size() > 0)
{
const NukiOpener::LogEntry& entry = log.front();
// log_d("Log: %d-%d-%d %d:%d:%d %s", entry.timeStampYear, entry.timeStampMonth, entry.timeStampDay,
// entry.timeStampHour, entry.timeStampMinute, entry.timeStampSecond, entry.name);
if(entry.authId != _lastAuthId)
{
_network->publishAuthorizationInfo(entry.authId, (char *) entry.name);
_lastAuthId = entry.authId;
}
}
else
{
_network->publishAuthorizationInfo(0, "");
}
}
NukiOpener::LockAction NukiOpenerWrapper::lockActionToEnum(const char *str)
{
if(strcmp(str, "activateRTO") == 0) return NukiOpener::LockAction::ActivateRTO;
else if(strcmp(str, "deactivateRTO") == 0) return NukiOpener::LockAction::DeactivateRTO;
else if(strcmp(str, "electricStrikeActuation") == 0) return NukiOpener::LockAction::ElectricStrikeActuation;
else if(strcmp(str, "activateCM") == 0) return NukiOpener::LockAction::ActivateCM;
else if(strcmp(str, "deactivateCM") == 0) return NukiOpener::LockAction::DeactivateCM;
else if(strcmp(str, "fobAction2") == 0) return NukiOpener::LockAction::FobAction2;
else if(strcmp(str, "fobAction1") == 0) return NukiOpener::LockAction::FobAction1;
else if(strcmp(str, "fobAction3") == 0) return NukiOpener::LockAction::FobAction3;
return (NukiOpener::LockAction)0xff;
}
bool NukiOpenerWrapper::onLockActionReceivedCallback(const char *value)
{
NukiOpener::LockAction action = nukiOpenerInst->lockActionToEnum(value);
nukiOpenerInst->_nextLockAction = action;
return (int)action != 0xff;
}
void NukiOpenerWrapper::onConfigUpdateReceivedCallback(const char *topic, const char *value)
{
nukiOpenerInst->onConfigUpdateReceived(topic, value);
}
void NukiOpenerWrapper::onConfigUpdateReceived(const char *topic, const char *value)
{
if(strcmp(topic, mqtt_topic_config_button_enabled) == 0)
{
bool newValue = atoi(value) > 0;
if(!_nukiConfigValid || _nukiConfig.buttonEnabled == newValue) return;
_nukiBle.enableButton(newValue);
_nextConfigUpdateTs = millis() + 300;
}
if(strcmp(topic, mqtt_topic_config_led_enabled) == 0)
{
bool newValue = atoi(value) > 0;
if(!_nukiConfigValid || _nukiConfig.ledEnabled == newValue) return;
_nukiBle.enableLedFlash(newValue);
_nextConfigUpdateTs = millis() + 300;
}
else if(strcmp(topic, mqtt_topic_config_led_brightness) == 0)
{
int newValue = atoi(value);
if(!_nukiConfigValid || _nukiConfig.ledBrightness == newValue) return;
_nukiBle.setLedBrightness(newValue);
_nextConfigUpdateTs = millis() + 300;
}
else if(strcmp(topic, mqtt_topic_config_auto_unlock) == 0)
{
bool newValue = !(atoi(value) > 0);
if(!_nukiAdvancedConfigValid || _nukiAdvancedConfig.autoUnLockDisabled == newValue) return;
_nukiBle.disableAutoUnlock(newValue);
_nextConfigUpdateTs = millis() + 300;
}
else if(strcmp(topic, mqtt_topic_config_auto_lock) == 0)
{
bool newValue = atoi(value) > 0;
if(!_nukiAdvancedConfigValid || _nukiAdvancedConfig.autoLockEnabled == newValue) return;
_nukiBle.enableAutoLock(newValue);
_nextConfigUpdateTs = millis() + 300;
}
else if(strcmp(topic, mqtt_topic_config_auto_lock) == 0)
{
bool newValue = atoi(value) > 0;
if(!_nukiAdvancedConfigValid || _nukiAdvancedConfig.autoLockEnabled == newValue) return;
_nukiBle.enableAutoLock(newValue);
_nextConfigUpdateTs = millis() + 300;
}
}
const NukiOpener::KeyTurnerState &NukiOpenerWrapper::keyTurnerState()
{
return _keyTurnerState;
}
const bool NukiOpenerWrapper::isPaired()
{
return _paired;
}
BleScanner::Scanner *NukiOpenerWrapper::bleScanner()
{
return _bleScanner;
}
void NukiOpenerWrapper::notify(Nuki::EventType eventType)
{
if(eventType == Nuki::EventType::KeyTurnerStatusUpdated)
{
_statusUpdated = true;
}
}
void NukiOpenerWrapper::readConfig()
{
Serial.print(F("Reading config. Result: "));
Nuki::CmdResult result = _nukiBle.requestConfig(&_nukiConfig);
_nukiConfigValid = result == Nuki::CmdResult::Success;
Serial.println(result);
}
void NukiOpenerWrapper::readAdvancedConfig()
{
Serial.print(F("Reading advanced config. Result: "));
Nuki::CmdResult result = _nukiBle.requestAdvancedConfig(&_nukiAdvancedConfig);
_nukiAdvancedConfigValid = result == Nuki::CmdResult::Success;
Serial.println(result);
}

75
NukiOpenerWrapper.h Normal file
View File

@@ -0,0 +1,75 @@
#pragma once
#include "NukiOpener.h"
#include "Network.h"
#include "NukiOpenerConstants.h"
#include "NukiDataTypes.h"
#include "BleScanner.h"
class NukiOpenerWrapper : public NukiOpener::SmartlockEventHandler
{
public:
NukiOpenerWrapper(const std::string& deviceName, uint32_t id, Network* network, Preferences* preferences);
virtual ~NukiOpenerWrapper();
void initialize();
void update();
void setPin(const uint16_t pin);
void unpair();
const NukiOpener::KeyTurnerState& keyTurnerState();
const bool isPaired();
BleScanner::Scanner* bleScanner();
void notify(NukiOpener::EventType eventType) override;
private:
static bool onLockActionReceivedCallback(const char* value);
static void onConfigUpdateReceivedCallback(const char* topic, const char* value);
void onConfigUpdateReceived(const char* topic, const char* value);
void updateKeyTurnerState();
void updateBatteryState();
void updateConfig();
void updateAuthData();
void readConfig();
void readAdvancedConfig();
NukiOpener::LockAction lockActionToEnum(const char* str); // char array at least 14 characters
std::string _deviceName;
NukiOpener::NukiOpener _nukiBle;
BleScanner::Scanner* _bleScanner;
Network* _network;
Preferences* _preferences;
int _intervalLockstate = 0; // seconds
int _intervalBattery = 0; // seconds
int _intervalConfig = 60 * 60; // seconds
bool _publishAuthData = false;
bool _clearAuthData = false;
NukiOpener::KeyTurnerState _lastKeyTurnerState;
NukiOpener::KeyTurnerState _keyTurnerState;
uint32_t _lastAuthId = 0xffff;
NukiOpener::BatteryReport _batteryReport;
NukiOpener::BatteryReport _lastBatteryReport;
NukiOpener::Config _nukiConfig = {0};
NukiOpener::AdvancedConfig _nukiAdvancedConfig = {0};
bool _nukiConfigValid = false;
bool _nukiAdvancedConfigValid = false;
bool _paired = false;
bool _statusUpdated = false;
unsigned long _nextLockStateUpdateTs = 0;
unsigned long _nextBatteryReportTs = 0;
unsigned long _nextConfigUpdateTs = 0;
unsigned long _nextPairTs = 0;
NukiOpener::LockAction _nextLockAction = (NukiOpener::LockAction)0xff;
};

3
PreferencesKeys.h
View File

@@ -5,7 +5,8 @@
#define preference_mqtt_broker_port "mqttport"
#define preference_mqtt_user "mqttuser"
#define preference_mqtt_password "mqttpass"
#define preference_mqtt_path "mqttpath"
#define preference_mqtt_lock_path "mqttpath"
#define preference_mqtt_opener_path "mqttoppath"
#define preference_hostname "hostname"
#define preference_network_timeout "nettmout"
#define preference_query_interval_lockstate "lockStInterval"

10
WebCfgServer.cpp
View File

@@ -147,7 +147,12 @@ bool WebCfgServer::processArgs(String& message)
}
else if(key == "MQTTPATH")
{
_preferences->putString(preference_mqtt_path, value);
_preferences->putString(preference_mqtt_lock_path, value);
configChanged = true;
}
else if(key == "MQTTOPPATH")
{
_preferences->putString(preference_mqtt_opener_path, value);
configChanged = true;
}
else if(key == "HOSTNAME")
@@ -277,7 +282,8 @@ void WebCfgServer::buildHtml(String& response)
printInputField(response, "MQTTPORT", "MQTT Broker port", _preferences->getInt(preference_mqtt_broker_port), 5);
printInputField(response, "MQTTUSER", "MQTT User (# to clear)", _preferences->getString(preference_mqtt_user).c_str(), 30);
printInputField(response, "MQTTPASS", "MQTT Password", "*", 30, true);
printInputField(response, "MQTTPATH", "MQTT Path", _preferences->getString(preference_mqtt_path).c_str(), 180);
printInputField(response, "MQTTPATH", "MQTT Lock Path", _preferences->getString(preference_mqtt_lock_path).c_str(), 180);
printInputField(response, "MQTTOPPATH", "MQTT Opener Path", _preferences->getString(preference_mqtt_opener_path).c_str(), 180);
printInputField(response, "HOSTNAME", "Host name", _preferences->getString(preference_hostname).c_str(), 100);
printInputField(response, "NETTIMEOUT", "Network Timeout until restart (seconds; -1 to disable)", _preferences->getInt(preference_network_timeout), 5);
printInputField(response, "LSTINT", "Query interval lock state (seconds)", _preferences->getInt(preference_query_interval_lockstate), 10);

3
main.cpp
View File

@@ -8,10 +8,12 @@
#include "PresenceDetection.h"
#include "hardware/W5500EthServer.h"
#include "hardware/WifiEthServer.h"
#include "NukiOpenerWrapper.h"
Network* network = nullptr;
WebCfgServer* webCfgServer = nullptr;
NukiWrapper* nuki = nullptr;
NukiOpenerWrapper* nukiOpener = nullptr;
PresenceDetection* presenceDetection = nullptr;
Preferences* preferences = nullptr;
EthServer* ethServer = nullptr;
@@ -120,6 +122,7 @@ void setup()
initEthServer(networkDevice);
nuki = new NukiWrapper("NukiHub", deviceId, network, preferences);
// nukiOpener = new NukiOpenerWrapper("NukiHub", deviceId, network, preferences);
webCfgServer = new WebCfgServer(nuki, network, ethServer, preferences, networkDevice == NetworkDeviceType::WiFi);
webCfgServer->initialize();
nuki->initialize();