Merge pull request #594 from iranl/hybrid-and-auth
Various improvemnts and fixes
This commit is contained in:
@@ -244,6 +244,8 @@ In a browser navigate to the IP address assigned to the ESP32.
|
||||
- Enable hybrid official MQTT and Nuki Hub setup: Enable to combine the official MQTT over Thread/Wi-Fi with BLE. Improves speed of state changes. Needs the official MQTT to be setup first. Also requires Nuki Hub to be paired as app and unregistered as a bridge using the Nuki app. See [hybrid mode](/HYBRID.md)
|
||||
- Enable sending actions through official MQTT: Enable to sent lock actions through the official MQTT topics (e.g. over Thread/Wi-Fi) instead of using BLE. Needs "Enable hybrid official MQTT and Nuki Hub setup" to be enabled. See [hybrid mode](/HYBRID.md)
|
||||
- Time between status updates when official MQTT is offline (seconds): Set to a positive integer to set the maximum amount of seconds between actively querying the Nuki lock for the current lock state when the official MQTT is offline, default 600.
|
||||
- Retry command sent using official MQTT over BLE if failed: Enable to publish lock commands over BLE if NukiHub fails to use Hybrid mode to execute the command over MQTT
|
||||
- Reboot Nuki lock on official MQTT failure: Enable to reboot the Nuki Lock if official MQTT over WiFi/Thread is offline for more than 180 seconds
|
||||
|
||||
### Nuki Configuration
|
||||
|
||||
|
||||
Submodule lib/nuki_ble updated: 84865a9eed...8798980767
@@ -5,7 +5,7 @@
|
||||
#define NUKI_HUB_VERSION "9.07"
|
||||
#define NUKI_HUB_VERSION_INT (uint32_t)907
|
||||
#define NUKI_HUB_BUILD "unknownbuildnr"
|
||||
#define NUKI_HUB_DATE "2025-01-04"
|
||||
#define NUKI_HUB_DATE "2025-01-05"
|
||||
|
||||
#define GITHUB_LATEST_RELEASE_URL (char*)"https://github.com/technyon/nuki_hub/releases/latest"
|
||||
#define GITHUB_OTA_MANIFEST_URL (char*)"https://raw.githubusercontent.com/technyon/nuki_hub/binary/ota/manifest.json"
|
||||
|
||||
14
src/Gpio.cpp
14
src/Gpio.cpp
@@ -216,7 +216,7 @@ void Gpio::loadPinConfiguration()
|
||||
{
|
||||
PinEntry entry;
|
||||
entry.pin = serialized[i * 2];
|
||||
Log->print(F("Pin "));
|
||||
Log->print(("Pin "));
|
||||
Log->println(entry.pin);
|
||||
|
||||
if(std::find(disabledPins.begin(), disabledPins.end(), entry.pin) == disabledPins.end())
|
||||
@@ -227,14 +227,14 @@ void Gpio::loadPinConfiguration()
|
||||
}
|
||||
entry.role = (PinRole) serialized[(i * 2 + 1)];
|
||||
Log->println("Not found in Ethernet disabled pins");
|
||||
Log->print(F("Role: "));
|
||||
Log->print(("Role: "));
|
||||
Log->println(getRoleDescription(entry.role));
|
||||
}
|
||||
else
|
||||
{
|
||||
entry.role = PinRole::Ethernet;
|
||||
Log->println("Found in Ethernet disabled pins");
|
||||
Log->print(F("Role: "));
|
||||
Log->print(("Role: "));
|
||||
Log->println(getRoleDescription(entry.role));
|
||||
}
|
||||
if(entry.role != PinRole::Disabled)
|
||||
@@ -331,7 +331,7 @@ const std::vector<int> Gpio::getDisabledPins() const
|
||||
break;
|
||||
}
|
||||
|
||||
Log->print(F("GPIO Ethernet disabled pins:"));
|
||||
Log->print(("GPIO Ethernet disabled pins:"));
|
||||
for_each_n(disabledPins.begin(), disabledPins.size(),
|
||||
[](int x)
|
||||
{
|
||||
@@ -354,7 +354,7 @@ void Gpio::savePinConfiguration(const std::vector<PinEntry> &pinConfiguration)
|
||||
for(int i=0; i < len; i++)
|
||||
{
|
||||
const auto& entry = pinConfiguration[i];
|
||||
Log->print(F("Pin "));
|
||||
Log->print(("Pin "));
|
||||
Log->println(entry.pin);
|
||||
|
||||
if(std::find(disabledPins.begin(), disabledPins.end(), entry.pin) != disabledPins.end())
|
||||
@@ -362,7 +362,7 @@ void Gpio::savePinConfiguration(const std::vector<PinEntry> &pinConfiguration)
|
||||
serialized[i * 2] = entry.pin;
|
||||
serialized[i * 2 + 1] = (int8_t)PinRole::Ethernet;
|
||||
Log->println("Found in Ethernet disabled pins");
|
||||
Log->print(F("Role: "));
|
||||
Log->print(("Role: "));
|
||||
Log->println(getRoleDescription(PinRole::Ethernet));
|
||||
|
||||
}
|
||||
@@ -373,7 +373,7 @@ void Gpio::savePinConfiguration(const std::vector<PinEntry> &pinConfiguration)
|
||||
serialized[i * 2] = entry.pin;
|
||||
serialized[i * 2 + 1] = (int8_t) entry.role;
|
||||
Log->println("Not found in Ethernet disabled pins");
|
||||
Log->print(F("Role: "));
|
||||
Log->print(("Role: "));
|
||||
Log->println(getRoleDescription(entry.role));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
#define mqtt_topic_lock_binary_ring (char*)"/binaryRing"
|
||||
#define mqtt_topic_lock_trigger (char*)"/trigger"
|
||||
#define mqtt_topic_lock_last_lock_action (char*)"/lastLockAction"
|
||||
#define mqtt_topic_lock_lock_action_context (char*)"/lockActionContext"
|
||||
#define mqtt_topic_lock_log (char*)"/log"
|
||||
#define mqtt_topic_lock_log_latest (char*)"/shortLog"
|
||||
#define mqtt_topic_lock_log_rolling (char*)"/rollingLog"
|
||||
|
||||
@@ -72,7 +72,7 @@ void NukiNetwork::setupDevice()
|
||||
{
|
||||
_ipConfiguration = new IPConfiguration(_preferences);
|
||||
int hardwareDetect = _preferences->getInt(preference_network_hardware, 0);
|
||||
Log->print(F("Hardware detect: "));
|
||||
Log->print(("Hardware detect: "));
|
||||
Log->println(hardwareDetect);
|
||||
|
||||
_firstBootAfterDeviceChange = _preferences->getBool(preference_ntw_reconfigure, false);
|
||||
@@ -100,13 +100,13 @@ void NukiNetwork::setupDevice()
|
||||
#ifndef CONFIG_IDF_TARGET_ESP32H2
|
||||
if(!_firstBootAfterDeviceChange)
|
||||
{
|
||||
Log->println(F("Failed to connect to network. Wi-Fi fallback is disabled, rebooting."));
|
||||
Log->println(("Failed to connect to network. Wi-Fi fallback is disabled, rebooting."));
|
||||
wifiFallback = false;
|
||||
sleep(5);
|
||||
restartEsp(RestartReason::NetworkDeviceCriticalFailureNoWifiFallback);
|
||||
}
|
||||
|
||||
Log->println(F("Switching to Wi-Fi device as fallback."));
|
||||
Log->println(("Switching to Wi-Fi device as fallback."));
|
||||
_networkDeviceType = NetworkDeviceType::WiFi;
|
||||
#else
|
||||
int custEth = _preferences->getInt(preference_network_custom_phy, 0);
|
||||
@@ -130,7 +130,7 @@ void NukiNetwork::setupDevice()
|
||||
|
||||
_device = NetworkDeviceInstantiator::Create(_networkDeviceType, _hostname, _preferences, _ipConfiguration);
|
||||
|
||||
Log->print(F("Network device: "));
|
||||
Log->print(("Network device: "));
|
||||
Log->println(_device->deviceName());
|
||||
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
@@ -194,6 +194,15 @@ bool NukiNetwork::isConnected()
|
||||
return _device->isConnected();
|
||||
}
|
||||
|
||||
bool NukiNetwork::mqttConnected()
|
||||
{
|
||||
#ifndef NUKI_HUB_UPDATER
|
||||
return _device->mqttConnected();
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool NukiNetwork::wifiConnected()
|
||||
{
|
||||
if(_networkDeviceType != NetworkDeviceType::WiFi)
|
||||
@@ -220,7 +229,7 @@ void NukiNetwork::initialize()
|
||||
strcpy(_hostnameArr, _hostname.c_str());
|
||||
_device->initialize();
|
||||
|
||||
Log->print(F("Host name: "));
|
||||
Log->print(("Host name: "));
|
||||
Log->println(_hostname);
|
||||
}
|
||||
|
||||
@@ -270,7 +279,7 @@ void NukiNetwork::initialize()
|
||||
strcpy(_hostnameArr, _hostname.c_str());
|
||||
_device->initialize();
|
||||
|
||||
Log->print(F("Host name: "));
|
||||
Log->print(("Host name: "));
|
||||
Log->println(_hostname);
|
||||
|
||||
String brokerAddr = _preferences->getString(preference_mqtt_broker);
|
||||
@@ -297,9 +306,9 @@ void NukiNetwork::initialize()
|
||||
}
|
||||
}
|
||||
|
||||
Log->print(F("MQTT Broker: "));
|
||||
Log->print(("MQTT Broker: "));
|
||||
Log->print(_mqttBrokerAddr);
|
||||
Log->print(F(":"));
|
||||
Log->print((":"));
|
||||
Log->println(_mqttPort);
|
||||
|
||||
_device->mqttSetClientId(_hostnameArr);
|
||||
@@ -311,7 +320,7 @@ void NukiNetwork::initialize()
|
||||
|
||||
if(rebGpio)
|
||||
{
|
||||
Log->println(F("Rebuild MQTT GPIO structure"));
|
||||
Log->println(("Rebuild MQTT GPIO structure"));
|
||||
}
|
||||
for (const auto &pinEntry: _gpio->pinConfiguration())
|
||||
{
|
||||
@@ -413,7 +422,7 @@ bool NukiNetwork::update()
|
||||
if(_logIp && _device->isConnected() && !_device->localIP().equals("0.0.0.0"))
|
||||
{
|
||||
_logIp = false;
|
||||
Log->print(F("IP: "));
|
||||
Log->print(("IP: "));
|
||||
Log->println(_device->localIP());
|
||||
_firstDisconnected = true;
|
||||
}
|
||||
@@ -576,9 +585,9 @@ bool NukiNetwork::update()
|
||||
buildMqttPath(gpioPath, {mqtt_topic_gpio_prefix, (mqtt_topic_gpio_pin + std::to_string(pin)).c_str(), mqtt_topic_gpio_state});
|
||||
publishInt(_lockPath.c_str(), gpioPath, pinState, _retainGpio);
|
||||
|
||||
Log->print(F("GPIO "));
|
||||
Log->print(("GPIO "));
|
||||
Log->print(pin);
|
||||
Log->print(F(" (Input) --> "));
|
||||
Log->print((" (Input) --> "));
|
||||
Log->println(pinState);
|
||||
}
|
||||
}
|
||||
@@ -598,31 +607,31 @@ void NukiNetwork::onMqttDisconnect(const espMqttClientTypes::DisconnectReason &r
|
||||
switch(reason)
|
||||
{
|
||||
case espMqttClientTypes::DisconnectReason::USER_OK:
|
||||
Log->println(F("USER_OK"));
|
||||
Log->println(("USER_OK"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_UNACCEPTABLE_PROTOCOL_VERSION:
|
||||
Log->println(F("MQTT_UNACCEPTABLE_PROTOCOL_VERSION"));
|
||||
Log->println(("MQTT_UNACCEPTABLE_PROTOCOL_VERSION"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_IDENTIFIER_REJECTED:
|
||||
Log->println(F("MQTT_IDENTIFIER_REJECTED"));
|
||||
Log->println(("MQTT_IDENTIFIER_REJECTED"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_SERVER_UNAVAILABLE:
|
||||
Log->println(F("MQTT_SERVER_UNAVAILABLE"));
|
||||
Log->println(("MQTT_SERVER_UNAVAILABLE"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_MALFORMED_CREDENTIALS:
|
||||
Log->println(F("MQTT_MALFORMED_CREDENTIALS"));
|
||||
Log->println(("MQTT_MALFORMED_CREDENTIALS"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::MQTT_NOT_AUTHORIZED:
|
||||
Log->println(F("MQTT_NOT_AUTHORIZED"));
|
||||
Log->println(("MQTT_NOT_AUTHORIZED"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::TLS_BAD_FINGERPRINT:
|
||||
Log->println(F("TLS_BAD_FINGERPRINT"));
|
||||
Log->println(("TLS_BAD_FINGERPRINT"));
|
||||
break;
|
||||
case espMqttClientTypes::DisconnectReason::TCP_DISCONNECTED:
|
||||
Log->println(F("TCP_DISCONNECTED"));
|
||||
Log->println(("TCP_DISCONNECTED"));
|
||||
break;
|
||||
default:
|
||||
Log->println(F("Unknown"));
|
||||
Log->println(("Unknown"));
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -635,7 +644,7 @@ bool NukiNetwork::reconnect()
|
||||
{
|
||||
if(strcmp(_mqttBrokerAddr, "") == 0)
|
||||
{
|
||||
Log->println(F("MQTT Broker not configured, aborting connection attempt."));
|
||||
Log->println(("MQTT Broker not configured, aborting connection attempt."));
|
||||
_nextReconnect = espMillis() + 5000;
|
||||
|
||||
if(_device->isConnected())
|
||||
@@ -645,17 +654,17 @@ bool NukiNetwork::reconnect()
|
||||
return false;
|
||||
}
|
||||
|
||||
Log->println(F("Attempting MQTT connection"));
|
||||
Log->println(("Attempting MQTT connection"));
|
||||
|
||||
_connectReplyReceived = false;
|
||||
|
||||
if(strlen(_mqttUser) == 0)
|
||||
{
|
||||
Log->println(F("MQTT: Connecting without credentials"));
|
||||
Log->println(("MQTT: Connecting without credentials"));
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->print(F("MQTT: Connecting with user: "));
|
||||
Log->print(("MQTT: Connecting with user: "));
|
||||
Log->println(_mqttUser);
|
||||
_device->mqttSetCredentials(_mqttUser, _mqttPass);
|
||||
}
|
||||
@@ -678,7 +687,7 @@ bool NukiNetwork::reconnect()
|
||||
|
||||
if (_device->mqttConnected())
|
||||
{
|
||||
Log->println(F("MQTT connected"));
|
||||
Log->println(("MQTT connected"));
|
||||
_mqttConnectedTs = millis();
|
||||
_mqttConnectionState = 1;
|
||||
delay(100);
|
||||
@@ -757,6 +766,9 @@ bool NukiNetwork::reconnect()
|
||||
|
||||
initTopic(_maintenancePathPrefix, mqtt_topic_reset, "0");
|
||||
subscribe(_maintenancePathPrefix, mqtt_topic_reset);
|
||||
initTopic(_maintenancePathPrefix, mqtt_topic_freeheap, "");
|
||||
initTopic(_maintenancePathPrefix, mqtt_topic_log, "");
|
||||
initTopic(_maintenancePathPrefix, mqtt_topic_wifi_rssi, "");
|
||||
|
||||
if(_preferences->getBool(preference_update_from_mqtt, false))
|
||||
{
|
||||
@@ -790,7 +802,7 @@ bool NukiNetwork::reconnect()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->print(F("MQTT connect failed"));
|
||||
Log->print(("MQTT connect failed"));
|
||||
_mqttConnectionState = 0;
|
||||
_nextReconnect = espMillis() + 5000;
|
||||
//_device->mqttDisconnect(true);
|
||||
@@ -909,14 +921,14 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
|
||||
if(comparePrefixedPath(topic, mqtt_topic_reset) && strcmp(data, "1") == 0 && !mqttRecentlyConnected())
|
||||
{
|
||||
Log->println(F("Restart requested via MQTT."));
|
||||
Log->println(("Restart requested via MQTT."));
|
||||
clearWifiFallback();
|
||||
delay(200);
|
||||
restartEsp(RestartReason::RequestedViaMqtt);
|
||||
}
|
||||
else if(comparePrefixedPath(topic, mqtt_topic_update) && strcmp(data, "1") == 0 && _preferences->getBool(preference_update_from_mqtt, false))
|
||||
{
|
||||
Log->println(F("Update requested via MQTT."));
|
||||
Log->println(("Update requested via MQTT."));
|
||||
|
||||
bool otaManifestSuccess = false;
|
||||
JsonDocument doc;
|
||||
@@ -957,13 +969,13 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
{
|
||||
if(strcmp(NUKI_HUB_VERSION, doc["release"]["fullversion"].as<const char*>()) == 0 && strcmp(NUKI_HUB_BUILD, doc["release"]["build"].as<const char*>()) == 0 && strcmp(NUKI_HUB_DATE, doc["release"]["time"].as<const char*>()) == 0)
|
||||
{
|
||||
Log->println(F("Nuki Hub is already on the latest release version, OTA update aborted."));
|
||||
Log->println(("Nuki Hub is already on the latest release version, OTA update aborted."));
|
||||
}
|
||||
else
|
||||
{
|
||||
_preferences->putString(preference_ota_updater_url, GITHUB_LATEST_UPDATER_BINARY_URL);
|
||||
_preferences->putString(preference_ota_main_url, GITHUB_LATEST_RELEASE_BINARY_URL);
|
||||
Log->println(F("Updating to latest release version."));
|
||||
Log->println(("Updating to latest release version."));
|
||||
delay(200);
|
||||
restartEsp(RestartReason::OTAReboot);
|
||||
}
|
||||
@@ -972,13 +984,13 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
{
|
||||
if(strcmp(NUKI_HUB_VERSION, doc["beta"]["fullversion"].as<const char*>()) == 0 && strcmp(NUKI_HUB_BUILD, doc["beta"]["build"].as<const char*>()) == 0 && strcmp(NUKI_HUB_DATE, doc["beta"]["time"].as<const char*>()) == 0)
|
||||
{
|
||||
Log->println(F("Nuki Hub is already on the latest beta version, OTA update aborted."));
|
||||
Log->println(("Nuki Hub is already on the latest beta version, OTA update aborted."));
|
||||
}
|
||||
else
|
||||
{
|
||||
_preferences->putString(preference_ota_updater_url, GITHUB_BETA_UPDATER_BINARY_URL);
|
||||
_preferences->putString(preference_ota_main_url, GITHUB_BETA_RELEASE_BINARY_URL);
|
||||
Log->println(F("Updating to latest beta version."));
|
||||
Log->println(("Updating to latest beta version."));
|
||||
delay(200);
|
||||
restartEsp(RestartReason::OTAReboot);
|
||||
}
|
||||
@@ -987,13 +999,13 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
{
|
||||
if(strcmp(NUKI_HUB_VERSION, doc["master"]["fullversion"].as<const char*>()) == 0 && strcmp(NUKI_HUB_BUILD, doc["master"]["build"].as<const char*>()) == 0 && strcmp(NUKI_HUB_DATE, doc["master"]["time"].as<const char*>()) == 0)
|
||||
{
|
||||
Log->println(F("Nuki Hub is already on the latest development version, OTA update aborted."));
|
||||
Log->println(("Nuki Hub is already on the latest development version, OTA update aborted."));
|
||||
}
|
||||
else
|
||||
{
|
||||
_preferences->putString(preference_ota_updater_url, GITHUB_MASTER_UPDATER_BINARY_URL);
|
||||
_preferences->putString(preference_ota_main_url, GITHUB_MASTER_RELEASE_BINARY_URL);
|
||||
Log->println(F("Updating to latest developmemt version."));
|
||||
Log->println(("Updating to latest developmemt version."));
|
||||
delay(200);
|
||||
restartEsp(RestartReason::OTAReboot);
|
||||
}
|
||||
@@ -1002,13 +1014,13 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
{
|
||||
if(strcmp(NUKI_HUB_VERSION, doc["release"]["fullversion"].as<const char*>()) == 0 && strcmp(NUKI_HUB_BUILD, doc["release"]["build"].as<const char*>()) == 0 && strcmp(NUKI_HUB_DATE, doc["release"]["time"].as<const char*>()) == 0)
|
||||
{
|
||||
Log->println(F("Nuki Hub is already on the latest release version, OTA update aborted."));
|
||||
Log->println(("Nuki Hub is already on the latest release version, OTA update aborted."));
|
||||
}
|
||||
else
|
||||
{
|
||||
_preferences->putString(preference_ota_updater_url, GITHUB_LATEST_UPDATER_BINARY_URL);
|
||||
_preferences->putString(preference_ota_main_url, GITHUB_LATEST_RELEASE_BINARY_URL);
|
||||
Log->println(F("Updating to latest release version."));
|
||||
Log->println(("Updating to latest release version."));
|
||||
delay(200);
|
||||
restartEsp(RestartReason::OTAReboot);
|
||||
}
|
||||
@@ -1016,7 +1028,7 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Failed to retrieve OTA manifest, OTA update aborted."));
|
||||
Log->println(("Failed to retrieve OTA manifest, OTA update aborted."));
|
||||
}
|
||||
}
|
||||
else if(comparePrefixedPath(topic, mqtt_topic_webserver_action))
|
||||
@@ -1033,7 +1045,7 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
{
|
||||
return;
|
||||
}
|
||||
Log->println(F("Webserver enabled, restarting."));
|
||||
Log->println(("Webserver enabled, restarting."));
|
||||
_preferences->putBool(preference_webserver_enabled, true);
|
||||
|
||||
}
|
||||
@@ -1043,7 +1055,7 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
|
||||
{
|
||||
return;
|
||||
}
|
||||
Log->println(F("Webserver disabled, restarting."));
|
||||
Log->println(("Webserver disabled, restarting."));
|
||||
_preferences->putBool(preference_webserver_enabled, false);
|
||||
}
|
||||
|
||||
@@ -1073,9 +1085,9 @@ void NukiNetwork::parseGpioTopics(const espMqttClientTypes::MessageProperties &p
|
||||
if(_gpio->getPinRole(pin) == PinRole::GeneralOutput)
|
||||
{
|
||||
const uint8_t pinState = strcmp((const char*)payload, "1") == 0 ? HIGH : LOW;
|
||||
Log->print(F("GPIO "));
|
||||
Log->print(("GPIO "));
|
||||
Log->print(pin);
|
||||
Log->print(F(" (Output) --> "));
|
||||
Log->print((" (Output) --> "));
|
||||
Log->println(pinState);
|
||||
digitalWrite(pin, pinState);
|
||||
}
|
||||
@@ -1177,7 +1189,7 @@ void NukiNetwork::removeTopic(const String& mqttPath, const String& mqttTopic)
|
||||
publish(path.c_str(), "", true);
|
||||
|
||||
#ifdef DEBUG_NUKIHUB
|
||||
Log->print(F("Removing MQTT topic: "));
|
||||
Log->print(("Removing MQTT topic: "));
|
||||
Log->println(path.c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -28,6 +28,7 @@ public:
|
||||
void scan(bool passive = false, bool async = true);
|
||||
bool isApOpen();
|
||||
bool isConnected();
|
||||
bool mqttConnected();
|
||||
bool wifiConnected();
|
||||
void clearWifiFallback();
|
||||
|
||||
|
||||
@@ -45,12 +45,14 @@ void NukiNetworkLock::initialize()
|
||||
|
||||
_haEnabled = _preferences->getString(preference_mqtt_hass_discovery, "") != "";
|
||||
_disableNonJSON = _preferences->getBool(preference_disable_non_json, false);
|
||||
_hybridRebootOnDisconnect = _preferences->getBool(preference_hybrid_reboot_on_disconnect, false);
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_lock_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_lock_action);
|
||||
_network->initTopic(_mqttPath, mqtt_topic_config_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_config_action);
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_keypad, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_config, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_lockstate, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_battery, "0");
|
||||
@@ -58,6 +60,21 @@ void NukiNetworkLock::initialize()
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_lockstate);
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_battery);
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_auth_action, "--");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_timecontrol_action, "--");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_keypad_json_action, "--");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_lock_retry, "0");
|
||||
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_hybrid_state);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_config_action_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_keypad_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_keypad_json_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_timecontrol_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_auth_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_query_lockstate_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_lock_completionStatus);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_lock_action_command_result);
|
||||
|
||||
if(_disableNonJSON)
|
||||
{
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_keypad_command_action);
|
||||
@@ -110,21 +127,17 @@ void NukiNetworkLock::initialize()
|
||||
_network->subscribe(_mqttPath, mqtt_topic_keypad_command_enabled);
|
||||
}
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_keypad, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_keypad_json_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_keypad);
|
||||
_network->subscribe(_mqttPath, mqtt_topic_keypad_json_action);
|
||||
}
|
||||
|
||||
if(_preferences->getBool(preference_timecontrol_control_enabled))
|
||||
{
|
||||
_network->initTopic(_mqttPath, mqtt_topic_timecontrol_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_timecontrol_action);
|
||||
}
|
||||
|
||||
if(_preferences->getBool(preference_auth_control_enabled))
|
||||
{
|
||||
_network->initTopic(_mqttPath, mqtt_topic_auth_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_auth_action);
|
||||
}
|
||||
|
||||
@@ -142,20 +155,35 @@ void NukiNetworkLock::initialize()
|
||||
{
|
||||
_network->subscribe(_mqttPath, mqtt_topic_lock_log_rolling_last);
|
||||
}
|
||||
/*
|
||||
_network->addReconnectedCallback([&]()
|
||||
{
|
||||
_reconnected = true;
|
||||
});
|
||||
*/
|
||||
}
|
||||
|
||||
void NukiNetworkLock::update()
|
||||
bool NukiNetworkLock::update()
|
||||
{
|
||||
bool ret = false;
|
||||
|
||||
if(_nukiOfficial->hasOffStateToPublish())
|
||||
{
|
||||
publishState(_nukiOfficial->getOffStateToPublish());
|
||||
}
|
||||
|
||||
if(_hybridRebootOnDisconnect && _network->mqttConnected())
|
||||
{
|
||||
int64_t ts = espMillis();
|
||||
|
||||
if(_offConnected && !_nukiOfficial->getOffConnected())
|
||||
{
|
||||
_offLastConnected = ts;
|
||||
}
|
||||
else if(!_offConnected && _offLastConnected > 0 && _offLastConnected < (ts - (180 * 1000)))
|
||||
{
|
||||
_offLastConnected = 0;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
_offConnected = _nukiOfficial->getOffConnected();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void NukiNetworkLock::onMqttDataReceived(const char* topic, byte* payload, const unsigned int length)
|
||||
@@ -208,7 +236,7 @@ void NukiNetworkLock::onMqttDataReceived(const char* topic, byte* payload, const
|
||||
return;
|
||||
}
|
||||
|
||||
Log->print(F("Lock action received: "));
|
||||
Log->print(("Lock action received: "));
|
||||
Log->println(data);
|
||||
LockActionResult lockActionResult = LockActionResult::Failed;
|
||||
if(_lockActionReceivedCallback != NULL)
|
||||
@@ -496,7 +524,7 @@ void NukiNetworkLock::publishKeyTurnerState(const NukiLock::KeyTurnerState& keyT
|
||||
}
|
||||
|
||||
json["auth_id"] = getAuthId();
|
||||
json["auth_name"] = _authName;
|
||||
json["auth_name"] = getAuthName();
|
||||
|
||||
serializeJson(json, _buffer, _bufferSize);
|
||||
_nukiPublisher->publishString(mqtt_topic_lock_json, _buffer, true);
|
||||
@@ -697,10 +725,10 @@ void NukiNetworkLock::publishAuthorizationInfo(const std::list<NukiLock::LogEntr
|
||||
_nukiPublisher->publishString(mqtt_topic_lock_log, _buffer, true);
|
||||
}
|
||||
|
||||
if(authIndex > 0)
|
||||
if(authIndex > 0 || (_nukiOfficial->getOffConnected() && _nukiOfficial->hasAuthId()))
|
||||
{
|
||||
_nukiPublisher->publishUInt(mqtt_topic_lock_auth_id, getAuthId(), true);
|
||||
_nukiPublisher->publishString(mqtt_topic_lock_auth_name, _authName, true);
|
||||
_nukiPublisher->publishString(mqtt_topic_lock_auth_name, getAuthName(), true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -911,6 +939,7 @@ void NukiNetworkLock::publishKeypad(const std::list<NukiLock::KeypadEntry>& entr
|
||||
}
|
||||
jsonEntry["enabled"] = entry.enabled;
|
||||
jsonEntry["name"] = entry.name;
|
||||
_authEntries[jsonEntry["codeId"]] = jsonEntry["name"].as<String>();
|
||||
char createdDT[20];
|
||||
sprintf(createdDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.dateCreatedYear, entry.dateCreatedMonth, entry.dateCreatedDay, entry.dateCreatedHour, entry.dateCreatedMin, entry.dateCreatedSec);
|
||||
jsonEntry["dateCreated"] = createdDT;
|
||||
@@ -1276,7 +1305,7 @@ void NukiNetworkLock::publishAuth(const std::list<NukiLock::AuthorizationEntry>&
|
||||
auto jsonEntry = json.add<JsonVariant>();
|
||||
|
||||
jsonEntry["authId"] = entry.authId;
|
||||
jsonEntry["idType"] = entry.idType; //CONSIDER INT TO STRING
|
||||
jsonEntry["idType"] = entry.idType;
|
||||
jsonEntry["enabled"] = entry.enabled;
|
||||
jsonEntry["name"] = entry.name;
|
||||
_authEntries[jsonEntry["authId"]] = jsonEntry["name"].as<String>();
|
||||
@@ -1627,9 +1656,18 @@ void NukiNetworkLock::fobActionToString(const int fobact, char* str)
|
||||
|
||||
const uint32_t NukiNetworkLock::getAuthId() const
|
||||
{
|
||||
if(_nukiOfficial->hasAuthId())
|
||||
if(_nukiOfficial->getOffConnected() && _nukiOfficial->hasAuthId())
|
||||
{
|
||||
return _nukiOfficial->getAuthId();
|
||||
}
|
||||
return _authId;
|
||||
}
|
||||
|
||||
const char* NukiNetworkLock::getAuthName()
|
||||
{
|
||||
if(_nukiOfficial->getOffConnected() && _nukiOfficial->hasAuthId())
|
||||
{
|
||||
return _authEntries[getAuthId()].c_str();
|
||||
}
|
||||
return _authName;
|
||||
}
|
||||
@@ -23,7 +23,7 @@ public:
|
||||
virtual ~NukiNetworkLock();
|
||||
|
||||
void initialize();
|
||||
void update();
|
||||
bool update();
|
||||
|
||||
void publishKeyTurnerState(const NukiLock::KeyTurnerState& keyTurnerState, const NukiLock::KeyTurnerState& lastKeyTurnerState);
|
||||
void publishState(NukiLock::LockState lockState);
|
||||
@@ -59,6 +59,7 @@ public:
|
||||
void setupHASS(int type, uint32_t nukiId, char* nukiName, const char* firmwareVersion, const char* hardwareVersion, bool hasDoorSensor, bool hasKeypad);
|
||||
|
||||
const uint32_t getAuthId() const;
|
||||
const char* getAuthName();
|
||||
int mqttConnectionState();
|
||||
uint8_t queryCommands();
|
||||
|
||||
@@ -87,6 +88,8 @@ private:
|
||||
bool _firstTunerStatePublish = true;
|
||||
bool _haEnabled = false;
|
||||
bool _disableNonJSON = false;
|
||||
bool _offConnected = false;
|
||||
bool _hybridRebootOnDisconnect = false;
|
||||
|
||||
String _keypadCommandName = "";
|
||||
String _keypadCommandCode = "";
|
||||
@@ -95,6 +98,7 @@ private:
|
||||
uint8_t _queryCommands = 0;
|
||||
uint32_t _lastRollingLog = 0;
|
||||
uint32_t _authId = 0;
|
||||
int64_t _offLastConnected = 0;
|
||||
|
||||
char _nukiName[33];
|
||||
char _authName[33];
|
||||
|
||||
@@ -39,6 +39,7 @@ void NukiNetworkOpener::initialize()
|
||||
_network->initTopic(_mqttPath, mqtt_topic_config_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_config_action);
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_keypad, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_config, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_lockstate, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_battery, "0");
|
||||
@@ -47,6 +48,20 @@ void NukiNetworkOpener::initialize()
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_config);
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_lockstate);
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_battery);
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_keypad_json_action, "--");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_timecontrol_action, "--");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_auth_action, "--");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_lock_retry, "0");
|
||||
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_config_action_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_keypad_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_keypad_json_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_timecontrol_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_auth_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_query_lockstate_command_result);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_lock_completionStatus);
|
||||
_network->removeTopic(_mqttPath, mqtt_topic_lock_action_command_result);
|
||||
|
||||
if(_disableNonJSON)
|
||||
{
|
||||
@@ -94,21 +109,17 @@ void NukiNetworkOpener::initialize()
|
||||
_network->subscribe(_mqttPath, mqtt_topic_keypad_command_enabled);
|
||||
}
|
||||
|
||||
_network->initTopic(_mqttPath, mqtt_topic_query_keypad, "0");
|
||||
_network->initTopic(_mqttPath, mqtt_topic_keypad_json_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_query_keypad);
|
||||
_network->subscribe(_mqttPath, mqtt_topic_keypad_json_action);
|
||||
}
|
||||
|
||||
if(_preferences->getBool(preference_timecontrol_control_enabled, false))
|
||||
{
|
||||
_network->initTopic(_mqttPath, mqtt_topic_timecontrol_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_timecontrol_action);
|
||||
}
|
||||
|
||||
if(_preferences->getBool(preference_auth_control_enabled))
|
||||
{
|
||||
_network->initTopic(_mqttPath, mqtt_topic_auth_action, "--");
|
||||
_network->subscribe(_mqttPath, mqtt_topic_auth_action);
|
||||
}
|
||||
|
||||
@@ -116,12 +127,6 @@ void NukiNetworkOpener::initialize()
|
||||
{
|
||||
_network->subscribe(_mqttPath, mqtt_topic_lock_log_rolling_last);
|
||||
}
|
||||
/*
|
||||
_network->addReconnectedCallback([&]()
|
||||
{
|
||||
_reconnected = true;
|
||||
});
|
||||
*/
|
||||
}
|
||||
|
||||
void NukiNetworkOpener::update()
|
||||
@@ -170,7 +175,7 @@ void NukiNetworkOpener::onMqttDataReceived(const char* topic, byte* payload, con
|
||||
return;
|
||||
}
|
||||
|
||||
Log->print(F("Opener action received: "));
|
||||
Log->print(("Opener action received: "));
|
||||
Log->println(data);
|
||||
LockActionResult lockActionResult = LockActionResult::Failed;
|
||||
if(_lockActionReceivedCallback != NULL)
|
||||
@@ -655,12 +660,12 @@ void NukiNetworkOpener::publishAuthorizationInfo(const std::list<NukiOpener::Log
|
||||
{
|
||||
if((log.data[0] & 3) == 0)
|
||||
{
|
||||
Log->println(F("Nuki opener: Ring detected (Locked)"));
|
||||
Log->println(("Nuki opener: Ring detected (Locked)"));
|
||||
publishRing(true);
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Nuki opener: Ring detected (Open)"));
|
||||
Log->println(("Nuki opener: Ring detected (Open)"));
|
||||
publishRing(false);
|
||||
}
|
||||
}
|
||||
@@ -886,6 +891,7 @@ void NukiNetworkOpener::publishKeypad(const std::list<NukiLock::KeypadEntry>& en
|
||||
}
|
||||
jsonEntry["enabled"] = entry.enabled;
|
||||
jsonEntry["name"] = entry.name;
|
||||
_authEntries[jsonEntry["codeId"]] = jsonEntry["name"].as<String>();
|
||||
char createdDT[20];
|
||||
sprintf(createdDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.dateCreatedYear, entry.dateCreatedMonth, entry.dateCreatedDay, entry.dateCreatedHour, entry.dateCreatedMin, entry.dateCreatedSec);
|
||||
jsonEntry["dateCreated"] = createdDT;
|
||||
@@ -1218,7 +1224,7 @@ void NukiNetworkOpener::publishAuth(const std::list<NukiOpener::AuthorizationEnt
|
||||
auto jsonEntry = json.add<JsonVariant>();
|
||||
|
||||
jsonEntry["authId"] = entry.authId;
|
||||
jsonEntry["idType"] = entry.idType; //CONSIDER INT TO STRING
|
||||
jsonEntry["idType"] = entry.idType;
|
||||
jsonEntry["enabled"] = entry.enabled;
|
||||
jsonEntry["name"] = entry.name;
|
||||
_authEntries[jsonEntry["authId"]] = jsonEntry["name"].as<String>();
|
||||
|
||||
@@ -6,7 +6,6 @@
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
|
||||
|
||||
NukiOfficial::NukiOfficial(Preferences *preferences)
|
||||
{
|
||||
offEnabled = preferences->getBool(preference_official_hybrid_enabled, false);
|
||||
@@ -87,14 +86,14 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
memset(&str, 0, sizeof(str));
|
||||
|
||||
Log->println("Official Nuki change received");
|
||||
Log->print(F("Topic: "));
|
||||
Log->print(("Topic: "));
|
||||
Log->println(topic);
|
||||
Log->print(F("Value: "));
|
||||
Log->print(("Value: "));
|
||||
Log->println(value);
|
||||
|
||||
if(strcmp(topic, mqtt_topic_official_connected) == 0)
|
||||
{
|
||||
Log->print(F("Connected: "));
|
||||
Log->print(("Connected: "));
|
||||
Log->println((strcmp(value, "true") == 0 ? 1 : 0));
|
||||
offConnected = (strcmp(value, "true") == 0 ? 1 : 0);
|
||||
_publisher->publishBool(mqtt_topic_hybrid_state, offConnected, true);
|
||||
@@ -103,12 +102,12 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
{
|
||||
offState = atoi(value);
|
||||
_statusUpdated = true;
|
||||
Log->println(F("Lock: Updating status on Hybrid state change"));
|
||||
Log->println(("Lock: Updating status on Hybrid state change"));
|
||||
_publisher->publishBool(mqtt_topic_hybrid_state, offConnected, true);
|
||||
NukiLock::lockstateToString((NukiLock::LockState)offState, str);
|
||||
_publisher->publishString(mqtt_topic_lock_state, str, true);
|
||||
|
||||
Log->print(F("Lockstate: "));
|
||||
Log->print(("Lockstate: "));
|
||||
Log->println(str);
|
||||
|
||||
_offStateToPublish = (NukiLock::LockState)offState;
|
||||
@@ -118,11 +117,11 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
{
|
||||
offDoorsensorState = atoi(value);
|
||||
_statusUpdated = true;
|
||||
Log->println(F("Lock: Updating status on Hybrid door sensor state change"));
|
||||
Log->println(("Lock: Updating status on Hybrid door sensor state change"));
|
||||
_publisher->publishBool(mqtt_topic_lock_status_updated, _statusUpdated, true);
|
||||
NukiLock::doorSensorStateToString((NukiLock::DoorSensorState)offDoorsensorState, str);
|
||||
|
||||
Log->print(F("Doorsensor state: "));
|
||||
Log->print(("Doorsensor state: "));
|
||||
Log->println(str);
|
||||
|
||||
_publisher->publishString(mqtt_topic_lock_door_sensor_state, str, true);
|
||||
@@ -131,7 +130,7 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
{
|
||||
offCritical = (strcmp(value, "true") == 0 ? 1 : 0);
|
||||
|
||||
Log->print(F("Battery critical: "));
|
||||
Log->print(("Battery critical: "));
|
||||
Log->println(offCritical);
|
||||
|
||||
if(!_disableNonJSON)
|
||||
@@ -144,7 +143,7 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
{
|
||||
offCharging = (strcmp(value, "true") == 0 ? 1 : 0);
|
||||
|
||||
Log->print(F("Battery charging: "));
|
||||
Log->print(("Battery charging: "));
|
||||
Log->println(offCharging);
|
||||
|
||||
if(!_disableNonJSON)
|
||||
@@ -157,7 +156,7 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
{
|
||||
offChargeState = atoi(value);
|
||||
|
||||
Log->print(F("Battery level: "));
|
||||
Log->print(("Battery level: "));
|
||||
Log->println(offChargeState);
|
||||
|
||||
if(!_disableNonJSON)
|
||||
@@ -197,6 +196,7 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
}
|
||||
else if(strcmp(topic, mqtt_topic_official_lockActionEvent) == 0)
|
||||
{
|
||||
clearAuthId();
|
||||
clearOffCommandExecutedTs();
|
||||
offLockActionEvent = (char*)value;
|
||||
String LockActionEvent = offLockActionEvent;
|
||||
@@ -210,7 +210,7 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
offTrigger = atoi(LockActionEvent.substring(ind1 + 1, ind2 + 1).c_str());
|
||||
offAuthId = atoi(LockActionEvent.substring(ind2 + 1, ind3 + 1).c_str());
|
||||
offCodeId = atoi(LockActionEvent.substring(ind3 + 1, ind4 + 1).c_str());
|
||||
// offContext = atoi(LockActionEvent.substring(ind4 + 1, ind5 + 1).c_str());
|
||||
offContext = atoi(LockActionEvent.substring(ind4 + 1, ind5 + 1).c_str());
|
||||
|
||||
memset(&str, 0, sizeof(str));
|
||||
lockactionToString((NukiLock::LockAction)offLockAction, str);
|
||||
@@ -225,17 +225,69 @@ void NukiOfficial::onOfficialUpdateReceived(const char *topic, const char *value
|
||||
if(offCodeId > 0)
|
||||
{
|
||||
_authId = offCodeId;
|
||||
|
||||
switch(offContext)
|
||||
{
|
||||
case 0:
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "keypadBackKey", true);
|
||||
break;
|
||||
case 1:
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "keypadCode", true);
|
||||
break;
|
||||
case 2:
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "keypadFingerprint", true);
|
||||
break;
|
||||
default:
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "", true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_authId = offAuthId;
|
||||
|
||||
switch(offTrigger)
|
||||
{
|
||||
case 0:
|
||||
if (offContext == 1)
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "autoUnlock", true);
|
||||
}
|
||||
else
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "", true);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (offContext > 0)
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, String("button") + String(offContext) + "press", true);
|
||||
}
|
||||
else
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "", true);
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
if (offContext > 0)
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, String("fob") + String(offContext) + "press", true);
|
||||
}
|
||||
else
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "", true);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "", true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
_hasAuthId = true;
|
||||
|
||||
/*
|
||||
_network->_authName = RETRIEVE FROM VECTOR AFTER AUTHORIZATION ENTRIES ARE IMPLEMENTED;
|
||||
_offContext = BASE ON CONTEXT OF TRIGGER AND PUBLISH TO MQTT;
|
||||
*/
|
||||
}
|
||||
else
|
||||
{
|
||||
_publisher->publishString(mqtt_topic_lock_lock_action_context, "", true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -285,6 +337,7 @@ const bool NukiOfficial::hasAuthId() const
|
||||
void NukiOfficial::clearAuthId()
|
||||
{
|
||||
_hasAuthId = false;
|
||||
_authId = 0;
|
||||
}
|
||||
|
||||
const bool NukiOfficial::getOffConnected() const
|
||||
@@ -317,6 +370,11 @@ const uint8_t NukiOfficial::getOffTrigger() const
|
||||
return offTrigger;
|
||||
}
|
||||
|
||||
const uint8_t NukiOfficial::getOffContext() const
|
||||
{
|
||||
return offContext;
|
||||
}
|
||||
|
||||
const int64_t NukiOfficial::getOffCommandExecutedTs() const
|
||||
{
|
||||
return offCommandExecutedTs;
|
||||
|
||||
@@ -34,6 +34,7 @@ public:
|
||||
const uint8_t getOffState() const;
|
||||
const uint8_t getOffLockAction() const;
|
||||
const uint8_t getOffTrigger() const;
|
||||
const uint8_t getOffContext() const;
|
||||
const std::vector<char*> getOffTopics() const;
|
||||
|
||||
const int64_t getOffCommandExecutedTs() const;
|
||||
@@ -69,7 +70,7 @@ private:
|
||||
uint8_t offTrigger = 0;
|
||||
uint32_t offAuthId = 0;
|
||||
uint32_t offCodeId = 0;
|
||||
//uint8_t offContext = 0;
|
||||
uint8_t offContext = 0;
|
||||
bool offEnabled = false;
|
||||
};
|
||||
|
||||
|
||||
@@ -62,7 +62,7 @@ void NukiOpenerWrapper::initialize()
|
||||
_nukiOpener.registerBleScanner(_bleScanner);
|
||||
_nukiOpener.setEventHandler(this);
|
||||
_nukiOpener.setConnectTimeout(3);
|
||||
_nukiOpener.setDisconnectTimeout(5000);
|
||||
_nukiOpener.setDisconnectTimeout(2000);
|
||||
|
||||
_hassEnabled = _preferences->getBool(preference_mqtt_hass_enabled, false);
|
||||
readSettings();
|
||||
@@ -174,11 +174,11 @@ void NukiOpenerWrapper::readSettings()
|
||||
_preferences->putInt(preference_restart_ble_beacon_lost, _restartBeaconTimeout);
|
||||
}
|
||||
|
||||
Log->print(F("Opener state interval: "));
|
||||
Log->print(("Opener state interval: "));
|
||||
Log->print(_intervalLockstate);
|
||||
Log->print(F(" | Battery interval: "));
|
||||
Log->print((" | Battery interval: "));
|
||||
Log->print(_intervalBattery);
|
||||
Log->print(F(" | Publish auth data: "));
|
||||
Log->print((" | Publish auth data: "));
|
||||
Log->println(_publishAuthData ? "yes" : "no");
|
||||
|
||||
if(!_publishAuthData)
|
||||
@@ -195,7 +195,7 @@ void NukiOpenerWrapper::update()
|
||||
wdt_hal_write_protect_enable(&rtc_wdt_ctx);
|
||||
if(!_paired)
|
||||
{
|
||||
Log->println(F("Nuki opener start pairing"));
|
||||
Log->println(("Nuki opener start pairing"));
|
||||
_network->publishBleAddress("");
|
||||
|
||||
Nuki::AuthorizationIdType idType = _preferences->getBool(preference_register_opener_as_app) ?
|
||||
@@ -204,7 +204,7 @@ void NukiOpenerWrapper::update()
|
||||
|
||||
if(_nukiOpener.pairNuki(idType) == NukiOpener::PairingResult::Success)
|
||||
{
|
||||
Log->println(F("Nuki opener paired"));
|
||||
Log->println(("Nuki opener paired"));
|
||||
_paired = true;
|
||||
_network->publishBleAddress(_nukiOpener.getBleAddress().toString());
|
||||
}
|
||||
@@ -247,14 +247,14 @@ void NukiOpenerWrapper::update()
|
||||
|
||||
_network->publishCommandResult(resultStr);
|
||||
|
||||
Log->print(F("Opener action result: "));
|
||||
Log->print(("Opener action result: "));
|
||||
Log->println(resultStr);
|
||||
|
||||
if(cmdResult != Nuki::CmdResult::Success)
|
||||
{
|
||||
Log->print(F("Opener: Last command failed, retrying after "));
|
||||
Log->print(("Opener: Last command failed, retrying after "));
|
||||
Log->print(_retryDelay);
|
||||
Log->print(F(" milliseconds. Retry "));
|
||||
Log->print((" milliseconds. Retry "));
|
||||
Log->print(retryCount + 1);
|
||||
Log->print(" of ");
|
||||
Log->println(_nrOfRetries);
|
||||
@@ -274,7 +274,7 @@ void NukiOpenerWrapper::update()
|
||||
_network->publishRetry("--");
|
||||
retryCount = 0;
|
||||
_statusUpdated = true;
|
||||
Log->println(F("Opener: updating status after action"));
|
||||
Log->println(("Opener: updating status after action"));
|
||||
_statusUpdatedTs = ts;
|
||||
if(_intervalLockstate > 10)
|
||||
{
|
||||
@@ -283,7 +283,7 @@ void NukiOpenerWrapper::update()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Opener: Maximum number of retries exceeded, aborting."));
|
||||
Log->println(("Opener: Maximum number of retries exceeded, aborting."));
|
||||
_network->publishRetry("failed");
|
||||
retryCount = 0;
|
||||
_nextLockAction = (NukiOpener::LockAction) 0xff;
|
||||
@@ -336,7 +336,7 @@ void NukiOpenerWrapper::update()
|
||||
}
|
||||
if(_hassEnabled && _nukiConfigValid && _nukiAdvancedConfigValid && !_hassSetupCompleted)
|
||||
{
|
||||
_network->setupHASS(2, _nukiConfig.nukiId, (char*)_nukiConfig.name, _firmwareVersion.c_str(), _hardwareVersion.c_str(), false, _hasKeypad);
|
||||
_network->setupHASS(2, _nukiConfig.nukiId, (char*)_nukiConfig.name, _firmwareVersion.c_str(), _hardwareVersion.c_str(), false, hasKeypad());
|
||||
_hassSetupCompleted = true;
|
||||
}
|
||||
if(_rssiPublishInterval > 0 && (_nextRssiTs == 0 || ts > _nextRssiTs))
|
||||
@@ -350,7 +350,7 @@ void NukiOpenerWrapper::update()
|
||||
_lastRssi = rssi;
|
||||
}
|
||||
}
|
||||
if(_hasKeypad && _keypadEnabled && (_nextKeypadUpdateTs == 0 || ts > _nextKeypadUpdateTs || (queryCommands & QUERY_COMMAND_KEYPAD) > 0))
|
||||
if(hasKeypad() && _keypadEnabled && (_nextKeypadUpdateTs == 0 || ts > _nextKeypadUpdateTs || (queryCommands & QUERY_COMMAND_KEYPAD) > 0))
|
||||
{
|
||||
_nextKeypadUpdateTs = ts + _intervalKeypad * 1000;
|
||||
updateKeypad(false);
|
||||
@@ -452,7 +452,7 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
|
||||
|
||||
while(result != Nuki::CmdResult::Success && retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Result (attempt "));
|
||||
Log->print(("Result (attempt "));
|
||||
Log->print(retryCount + 1);
|
||||
Log->print("): ");
|
||||
result =_nukiOpener.requestOpenerState(&_keyTurnerState);
|
||||
@@ -471,7 +471,7 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
|
||||
postponeBleWatchdog();
|
||||
if(_retryLockstateCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Query opener state retrying in "));
|
||||
Log->print(("Query opener state retrying in "));
|
||||
Log->print(_retryDelay);
|
||||
Log->println("ms");
|
||||
_nextLockStateUpdateTs = espMillis() + _retryDelay;
|
||||
@@ -493,7 +493,7 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
|
||||
_lastKeyTurnerState.lockState == NukiOpener::LockState::Locked &&
|
||||
_lastKeyTurnerState.nukiState == _keyTurnerState.nukiState)
|
||||
{
|
||||
Log->println(F("Nuki opener: Ring detected (Locked)"));
|
||||
Log->println(("Nuki opener: Ring detected (Locked)"));
|
||||
_network->publishRing(true);
|
||||
}
|
||||
else
|
||||
@@ -503,15 +503,15 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
|
||||
_keyTurnerState.lockState == NukiOpener::LockState::Open &&
|
||||
_keyTurnerState.trigger == NukiOpener::Trigger::Manual)
|
||||
{
|
||||
Log->println(F("Nuki opener: Ring detected (Open)"));
|
||||
Log->println(("Nuki opener: Ring detected (Open)"));
|
||||
_network->publishRing(false);
|
||||
}
|
||||
|
||||
if(_publishAuthData)
|
||||
{
|
||||
Log->println(F("Publishing auth data"));
|
||||
Log->println(("Publishing auth data"));
|
||||
updateAuthData(false);
|
||||
Log->println(F("Done publishing auth data"));
|
||||
Log->println(("Done publishing auth data"));
|
||||
}
|
||||
|
||||
updateGpioOutputs();
|
||||
@@ -520,12 +520,12 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
|
||||
if((_keyTurnerState.lockState == NukiOpener::LockState::Open || _keyTurnerState.lockState == NukiOpener::LockState::Opening) && espMillis() < _statusUpdatedTs + 10000)
|
||||
{
|
||||
updateStatus = true;
|
||||
Log->println(F("Opener: Keep updating status on intermediate lock state"));
|
||||
Log->println(("Opener: Keep updating status on intermediate lock state"));
|
||||
}
|
||||
|
||||
if(_keyTurnerState.nukiState == NukiOpener::State::ContinuousMode)
|
||||
{
|
||||
Log->println(F("Continuous Mode"));
|
||||
Log->println(("Continuous Mode"));
|
||||
}
|
||||
|
||||
char lockStateStr[20];
|
||||
@@ -534,7 +534,7 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
|
||||
}
|
||||
|
||||
postponeBleWatchdog();
|
||||
Log->println(F("Done querying opener state"));
|
||||
Log->println(("Done querying opener state"));
|
||||
return updateStatus;
|
||||
}
|
||||
|
||||
@@ -545,7 +545,7 @@ void NukiOpenerWrapper::updateBatteryState()
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Querying opener battery state: "));
|
||||
Log->print(("Querying opener battery state: "));
|
||||
result = _nukiOpener.requestBatteryReport(&_batteryReport);
|
||||
delay(250);
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -564,7 +564,7 @@ void NukiOpenerWrapper::updateBatteryState()
|
||||
_network->publishBatteryReport(_batteryReport);
|
||||
}
|
||||
postponeBleWatchdog();
|
||||
Log->println(F("Done querying opener battery state"));
|
||||
Log->println(("Done querying opener battery state"));
|
||||
}
|
||||
|
||||
void NukiOpenerWrapper::updateConfig()
|
||||
@@ -579,7 +579,7 @@ void NukiOpenerWrapper::updateConfig()
|
||||
{
|
||||
char uidString[20];
|
||||
itoa(_nukiConfig.nukiId, uidString, 16);
|
||||
Log->print(F("Saving Opener Nuki ID to preferences ("));
|
||||
Log->print(("Saving Opener Nuki ID to preferences ("));
|
||||
Log->print(_nukiConfig.nukiId);
|
||||
Log->print(" / ");
|
||||
Log->print(uidString);
|
||||
@@ -612,7 +612,7 @@ void NukiOpenerWrapper::updateConfig()
|
||||
{
|
||||
Nuki::CmdResult result = (Nuki::CmdResult)-1;
|
||||
int retryCount = 0;
|
||||
Log->println(F("Nuki opener PIN is set"));
|
||||
Log->println(("Nuki opener PIN is set"));
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
@@ -630,7 +630,7 @@ void NukiOpenerWrapper::updateConfig()
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
{
|
||||
Log->println(F("Nuki opener PIN is invalid"));
|
||||
Log->println(("Nuki opener PIN is invalid"));
|
||||
if(pinStatus != 2)
|
||||
{
|
||||
_preferences->putInt(preference_opener_pin_status, 2);
|
||||
@@ -638,7 +638,7 @@ void NukiOpenerWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Nuki opener PIN is valid"));
|
||||
Log->println(("Nuki opener PIN is valid"));
|
||||
if(pinStatus != 1)
|
||||
{
|
||||
_preferences->putInt(preference_opener_pin_status, 1);
|
||||
@@ -647,7 +647,7 @@ void NukiOpenerWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Nuki opener PIN is not set"));
|
||||
Log->println(("Nuki opener PIN is not set"));
|
||||
if(pinStatus != 0)
|
||||
{
|
||||
_preferences->putInt(preference_opener_pin_status, 0);
|
||||
@@ -656,13 +656,13 @@ void NukiOpenerWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Invalid/Unexpected opener config received, ID does not matched saved ID"));
|
||||
Log->println(("Invalid/Unexpected opener config received, ID does not matched saved ID"));
|
||||
expectedConfig = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Invalid/Unexpected opener config received, Config is not valid"));
|
||||
Log->println(("Invalid/Unexpected opener config received, Config is not valid"));
|
||||
expectedConfig = false;
|
||||
}
|
||||
|
||||
@@ -679,7 +679,7 @@ void NukiOpenerWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Invalid/Unexpected opener advanced config received, Advanced config is not valid"));
|
||||
Log->println(("Invalid/Unexpected opener advanced config received, Advanced config is not valid"));
|
||||
expectedConfig = false;
|
||||
}
|
||||
}
|
||||
@@ -687,12 +687,12 @@ void NukiOpenerWrapper::updateConfig()
|
||||
if(expectedConfig && _nukiConfigValid && _nukiAdvancedConfigValid)
|
||||
{
|
||||
_retryConfigCount = 0;
|
||||
Log->println(F("Done retrieving opener config and advanced config"));
|
||||
Log->println(("Done retrieving opener config and advanced config"));
|
||||
}
|
||||
else
|
||||
{
|
||||
++_retryConfigCount;
|
||||
Log->println(F("Invalid/Unexpected opener config and/or advanced config received, retrying in 10 seconds"));
|
||||
Log->println(("Invalid/Unexpected opener config and/or advanced config received, retrying in 10 seconds"));
|
||||
int64_t ts = espMillis();
|
||||
_nextConfigUpdateTs = ts + 10000;
|
||||
}
|
||||
@@ -702,7 +702,7 @@ void NukiOpenerWrapper::updateAuthData(bool retrieved)
|
||||
{
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid PIN set"));
|
||||
Log->println(("No valid PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -713,7 +713,7 @@ void NukiOpenerWrapper::updateAuthData(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Retrieve log entries: "));
|
||||
Log->print(("Retrieve log entries: "));
|
||||
result = _nukiOpener.retrieveLogEntries(0, _preferences->getInt(preference_authlog_max_entries, MAX_AUTHLOG), 1, false);
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -767,7 +767,7 @@ void NukiOpenerWrapper::updateAuthData(bool retrieved)
|
||||
return a.index < b.index;
|
||||
});
|
||||
|
||||
Log->print(F("Log size: "));
|
||||
Log->print(("Log size: "));
|
||||
Log->println(log.size());
|
||||
|
||||
if(log.size() > 0)
|
||||
@@ -788,7 +788,7 @@ void NukiOpenerWrapper::updateKeypad(bool retrieved)
|
||||
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Opener PIN set"));
|
||||
Log->println(("No valid Nuki Opener PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -799,7 +799,7 @@ void NukiOpenerWrapper::updateKeypad(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Querying opener keypad: "));
|
||||
Log->print(("Querying opener keypad: "));
|
||||
result = _nukiOpener.retrieveKeypadEntries(0, _preferences->getInt(preference_keypad_max_entries, MAX_KEYPAD));
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -823,7 +823,7 @@ void NukiOpenerWrapper::updateKeypad(bool retrieved)
|
||||
std::list<NukiOpener::KeypadEntry> entries;
|
||||
_nukiOpener.getKeypadEntries(&entries);
|
||||
|
||||
Log->print(F("Opener keypad codes: "));
|
||||
Log->print(("Opener keypad codes: "));
|
||||
Log->println(entries.size());
|
||||
|
||||
entries.sort([](const NukiOpener::KeypadEntry& a, const NukiOpener::KeypadEntry& b)
|
||||
@@ -868,7 +868,7 @@ void NukiOpenerWrapper::updateTimeControl(bool retrieved)
|
||||
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Opener PIN set"));
|
||||
Log->println(("No valid Nuki Opener PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -879,7 +879,7 @@ void NukiOpenerWrapper::updateTimeControl(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Querying opener timecontrol: "));
|
||||
Log->print(("Querying opener timecontrol: "));
|
||||
result = _nukiOpener.retrieveTimeControlEntries();
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -903,7 +903,7 @@ void NukiOpenerWrapper::updateTimeControl(bool retrieved)
|
||||
std::list<NukiOpener::TimeControlEntry> timeControlEntries;
|
||||
_nukiOpener.getTimeControlEntries(&timeControlEntries);
|
||||
|
||||
Log->print(F("Opener timecontrol entries: "));
|
||||
Log->print(("Opener timecontrol entries: "));
|
||||
Log->println(timeControlEntries.size());
|
||||
|
||||
timeControlEntries.sort([](const NukiOpener::TimeControlEntry& a, const NukiOpener::TimeControlEntry& b)
|
||||
@@ -940,7 +940,7 @@ void NukiOpenerWrapper::updateAuth(bool retrieved)
|
||||
{
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Lock PIN set"));
|
||||
Log->println(("No valid Nuki Lock PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -956,7 +956,7 @@ void NukiOpenerWrapper::updateAuth(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries)
|
||||
{
|
||||
Log->print(F("Querying opener authorization: "));
|
||||
Log->print(("Querying opener authorization: "));
|
||||
result = _nukiOpener.retrieveAuthorizationEntries(0, _preferences->getInt(preference_auth_max_entries, MAX_AUTH));
|
||||
delay(250);
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -980,7 +980,7 @@ void NukiOpenerWrapper::updateAuth(bool retrieved)
|
||||
std::list<NukiOpener::AuthorizationEntry> authEntries;
|
||||
_nukiOpener.getAuthorizationEntries(&authEntries);
|
||||
|
||||
Log->print(F("Opener authorization entries: "));
|
||||
Log->print(("Opener authorization entries: "));
|
||||
Log->println(authEntries.size());
|
||||
|
||||
authEntries.sort([](const NukiOpener::AuthorizationEntry& a, const NukiOpener::AuthorizationEntry& b)
|
||||
@@ -2469,7 +2469,7 @@ void NukiOpenerWrapper::onKeypadCommandReceived(const char *command, const uint
|
||||
return;
|
||||
}
|
||||
|
||||
if(!_hasKeypad)
|
||||
if(!hasKeypad())
|
||||
{
|
||||
if(_nukiConfigValid)
|
||||
{
|
||||
@@ -2609,7 +2609,7 @@ void NukiOpenerWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
return;
|
||||
}
|
||||
|
||||
if(!_hasKeypad)
|
||||
if(!hasKeypad())
|
||||
{
|
||||
if(_nukiConfigValid)
|
||||
{
|
||||
@@ -2731,7 +2731,7 @@ void NukiOpenerWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
{
|
||||
auto it1 = std::find(_keypadCodeIds.begin(), _keypadCodeIds.end(), codeId);
|
||||
int index = it1 - _keypadCodeIds.begin();
|
||||
Log->print(F("Check keypad code: "));
|
||||
Log->print(("Check keypad code: "));
|
||||
|
||||
if(code == _keypadCodes[index])
|
||||
{
|
||||
@@ -2770,7 +2770,7 @@ void NukiOpenerWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
if(idExists)
|
||||
{
|
||||
result = _nukiOpener.deleteKeypadEntry(codeId);
|
||||
Log->print(F("Delete keypad code: "));
|
||||
Log->print(("Delete keypad code: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else
|
||||
@@ -2977,7 +2977,7 @@ void NukiOpenerWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
}
|
||||
|
||||
result = _nukiOpener.addKeypadEntry(entry);
|
||||
Log->print(F("Add keypad code: "));
|
||||
Log->print(("Add keypad code: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else if (strcmp(action, "update") == 0)
|
||||
@@ -3143,7 +3143,7 @@ void NukiOpenerWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
}
|
||||
|
||||
result = _nukiOpener.updateKeypadEntry(entry);
|
||||
Log->print(F("Update keypad code: "));
|
||||
Log->print(("Update keypad code: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
}
|
||||
@@ -3270,7 +3270,7 @@ void NukiOpenerWrapper::onTimeControlCommandReceived(const char *value)
|
||||
if(idExists)
|
||||
{
|
||||
result = _nukiOpener.removeTimeControlEntry(entryId);
|
||||
Log->print(F("Delete timecontrol: "));
|
||||
Log->print(("Delete timecontrol: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else
|
||||
@@ -3349,7 +3349,7 @@ void NukiOpenerWrapper::onTimeControlCommandReceived(const char *value)
|
||||
|
||||
entry.lockAction = timeControlLockAction;
|
||||
result = _nukiOpener.addTimeControlEntry(entry);
|
||||
Log->print(F("Add timecontrol: "));
|
||||
Log->print(("Add timecontrol: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else if (strcmp(action, "update") == 0)
|
||||
@@ -3426,7 +3426,7 @@ void NukiOpenerWrapper::onTimeControlCommandReceived(const char *value)
|
||||
|
||||
entry.lockAction = timeControlLockAction;
|
||||
result = _nukiOpener.updateTimeControlEntry(entry);
|
||||
Log->print(F("Update timecontrol: "));
|
||||
Log->print(("Update timecontrol: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
}
|
||||
@@ -3580,7 +3580,7 @@ void NukiOpenerWrapper::onAuthCommandReceived(const char *value)
|
||||
if(idExists)
|
||||
{
|
||||
result = _nukiOpener.deleteAuthorizationEntry(authId);
|
||||
Log->print(F("Delete authorization: "));
|
||||
Log->print(("Delete authorization: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else
|
||||
@@ -3799,7 +3799,7 @@ void NukiOpenerWrapper::onAuthCommandReceived(const char *value)
|
||||
}
|
||||
|
||||
result = _nukiOpener.addAuthorizationEntry(entry);
|
||||
Log->print(F("Add authorization: "));
|
||||
Log->print(("Add authorization: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else if (strcmp(action, "update") == 0)
|
||||
@@ -3964,7 +3964,7 @@ void NukiOpenerWrapper::onAuthCommandReceived(const char *value)
|
||||
}
|
||||
|
||||
result = _nukiOpener.updateAuthorizationEntry(entry);
|
||||
Log->print(F("Update authorization: "));
|
||||
Log->print(("Update authorization: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
}
|
||||
@@ -4013,7 +4013,7 @@ const bool NukiOpenerWrapper::isPaired() const
|
||||
|
||||
const bool NukiOpenerWrapper::hasKeypad() const
|
||||
{
|
||||
return _forceKeypad || _hasKeypad;
|
||||
return (_forceKeypad || _hasKeypad);
|
||||
}
|
||||
|
||||
const BLEAddress NukiOpenerWrapper::getBleAddress() const
|
||||
@@ -4077,7 +4077,7 @@ void NukiOpenerWrapper::readConfig()
|
||||
|
||||
char resultStr[20];
|
||||
NukiOpener::cmdResultToString(result, resultStr);
|
||||
Log->print(F("Opener config result: "));
|
||||
Log->print(("Opener config result: "));
|
||||
Log->print(resultStr);
|
||||
Log->print("(");
|
||||
Log->print(result);
|
||||
@@ -4107,7 +4107,7 @@ void NukiOpenerWrapper::readAdvancedConfig()
|
||||
|
||||
char resultStr[20];
|
||||
NukiOpener::cmdResultToString(result, resultStr);
|
||||
Log->print(F("Opener advanced config result: "));
|
||||
Log->print(("Opener advanced config result: "));
|
||||
Log->println(resultStr);
|
||||
postponeBleWatchdog();
|
||||
}
|
||||
@@ -4166,7 +4166,7 @@ void NukiOpenerWrapper::updateTime()
|
||||
{
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid PIN set"));
|
||||
Log->println(("No valid PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -4177,7 +4177,7 @@ void NukiOpenerWrapper::updateTime()
|
||||
|
||||
if (int(tm.tm_year + 1900) < int(2025))
|
||||
{
|
||||
Log->println(F("NTP Time not valid, not updating Nuki device"));
|
||||
Log->println(("NTP Time not valid, not updating Nuki device"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -4194,6 +4194,6 @@ void NukiOpenerWrapper::updateTime()
|
||||
char resultStr[15] = {0};
|
||||
NukiOpener::cmdResultToString(cmdResult, resultStr);
|
||||
|
||||
Log->print(F("Opener time update result: "));
|
||||
Log->print(("Opener time update result: "));
|
||||
Log->println(resultStr);
|
||||
}
|
||||
@@ -64,7 +64,7 @@ void NukiWrapper::initialize()
|
||||
_nukiLock.registerBleScanner(_bleScanner);
|
||||
_nukiLock.setEventHandler(this);
|
||||
_nukiLock.setConnectTimeout(3);
|
||||
_nukiLock.setDisconnectTimeout(5000);
|
||||
_nukiLock.setDisconnectTimeout(2000);
|
||||
|
||||
_hassEnabled = _preferences->getBool(preference_mqtt_hass_enabled, false);
|
||||
readSettings();
|
||||
@@ -183,11 +183,11 @@ void NukiWrapper::readSettings()
|
||||
_preferences->putInt(preference_restart_ble_beacon_lost, _restartBeaconTimeout);
|
||||
}
|
||||
|
||||
Log->print(F("Lock state interval: "));
|
||||
Log->print(("Lock state interval: "));
|
||||
Log->print(_intervalLockstate);
|
||||
Log->print(F(" | Battery interval: "));
|
||||
Log->print((" | Battery interval: "));
|
||||
Log->print(_intervalBattery);
|
||||
Log->print(F(" | Publish auth data: "));
|
||||
Log->print((" | Publish auth data: "));
|
||||
Log->println(_publishAuthData ? "yes" : "no");
|
||||
|
||||
if(!_publishAuthData)
|
||||
@@ -196,7 +196,7 @@ void NukiWrapper::readSettings()
|
||||
}
|
||||
}
|
||||
|
||||
void NukiWrapper::update()
|
||||
void NukiWrapper::update(bool reboot)
|
||||
{
|
||||
wdt_hal_context_t rtc_wdt_ctx = RWDT_HAL_CONTEXT_DEFAULT();
|
||||
wdt_hal_write_protect_disable(&rtc_wdt_ctx);
|
||||
@@ -204,8 +204,8 @@ void NukiWrapper::update()
|
||||
wdt_hal_write_protect_enable(&rtc_wdt_ctx);
|
||||
if(!_paired)
|
||||
{
|
||||
Log->println(F("Nuki lock start pairing"));
|
||||
_preferences->getBool(preference_register_as_app) ? Log->println(F("Pairing as app")) : Log->println(F("Pairing as bridge"));
|
||||
Log->println(("Nuki lock start pairing"));
|
||||
_preferences->getBool(preference_register_as_app) ? Log->println(("Pairing as app")) : Log->println(("Pairing as bridge"));
|
||||
_network->publishBleAddress("");
|
||||
|
||||
Nuki::AuthorizationIdType idType = _preferences->getBool(preference_register_as_app) ?
|
||||
@@ -214,7 +214,7 @@ void NukiWrapper::update()
|
||||
|
||||
if(_nukiLock.pairNuki(idType) == Nuki::PairingResult::Success)
|
||||
{
|
||||
Log->println(F("Nuki paired"));
|
||||
Log->println(("Nuki paired"));
|
||||
_paired = true;
|
||||
_network->publishBleAddress(_nukiLock.getBleAddress().toString());
|
||||
}
|
||||
@@ -261,14 +261,14 @@ void NukiWrapper::update()
|
||||
NukiLock::cmdResultToString(cmdResult, resultStr);
|
||||
_network->publishCommandResult(resultStr);
|
||||
|
||||
Log->print(F("Lock action result: "));
|
||||
Log->print(("Lock action result: "));
|
||||
Log->println(resultStr);
|
||||
|
||||
if(cmdResult != Nuki::CmdResult::Success)
|
||||
{
|
||||
Log->print(F("Lock: Last command failed, retrying after "));
|
||||
Log->print(("Lock: Last command failed, retrying after "));
|
||||
Log->print(_retryDelay);
|
||||
Log->print(F(" milliseconds. Retry "));
|
||||
Log->print((" milliseconds. Retry "));
|
||||
Log->print(retryCount + 1);
|
||||
Log->print(" of ");
|
||||
Log->println(_nrOfRetries);
|
||||
@@ -291,7 +291,7 @@ void NukiWrapper::update()
|
||||
{
|
||||
_statusUpdated = true;
|
||||
}
|
||||
Log->println(F("Lock: updating status after action"));
|
||||
Log->println(("Lock: updating status after action"));
|
||||
_statusUpdatedTs = ts;
|
||||
if(_intervalLockstate > 10)
|
||||
{
|
||||
@@ -300,7 +300,7 @@ void NukiWrapper::update()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Lock: Maximum number of retries exceeded, aborting."));
|
||||
Log->println(("Lock: Maximum number of retries exceeded, aborting."));
|
||||
_network->publishRetry("failed");
|
||||
retryCount = 0;
|
||||
_nextLockAction = (NukiLock::LockAction) 0xff;
|
||||
@@ -351,7 +351,7 @@ void NukiWrapper::update()
|
||||
}
|
||||
if(_hassEnabled && _nukiConfigValid && _nukiAdvancedConfigValid && !_hassSetupCompleted)
|
||||
{
|
||||
_network->setupHASS(1, _nukiConfig.nukiId, (char*)_nukiConfig.name, _firmwareVersion.c_str(), _hardwareVersion.c_str(), hasDoorSensor(), _hasKeypad);
|
||||
_network->setupHASS(1, _nukiConfig.nukiId, (char*)_nukiConfig.name, _firmwareVersion.c_str(), _hardwareVersion.c_str(), hasDoorSensor(), hasKeypad());
|
||||
_hassSetupCompleted = true;
|
||||
}
|
||||
if(_rssiPublishInterval > 0 && (_nextRssiTs == 0 || ts > _nextRssiTs))
|
||||
@@ -365,7 +365,7 @@ void NukiWrapper::update()
|
||||
_lastRssi = rssi;
|
||||
}
|
||||
}
|
||||
if(_hasKeypad && _keypadEnabled && (_nextKeypadUpdateTs == 0 || ts > _nextKeypadUpdateTs || (queryCommands & QUERY_COMMAND_KEYPAD) > 0))
|
||||
if(hasKeypad() && _keypadEnabled && (_nextKeypadUpdateTs == 0 || ts > _nextKeypadUpdateTs || (queryCommands & QUERY_COMMAND_KEYPAD) > 0))
|
||||
{
|
||||
Log->println("Updating Lock keypad based on timer or query");
|
||||
_nextKeypadUpdateTs = ts + _intervalKeypad * 1000;
|
||||
@@ -387,6 +387,10 @@ void NukiWrapper::update()
|
||||
{
|
||||
_invalidCount--;
|
||||
}
|
||||
if(reboot && isPinValid())
|
||||
{
|
||||
Nuki::CmdResult cmdResult = _nukiLock.requestReboot();
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(&_lastKeyTurnerState, &_keyTurnerState, sizeof(NukiLock::KeyTurnerState));
|
||||
@@ -458,13 +462,13 @@ bool NukiWrapper::updateKeyTurnerState()
|
||||
Nuki::CmdResult result = (Nuki::CmdResult)-1;
|
||||
int retryCount = 0;
|
||||
|
||||
Log->println(F("Querying lock state"));
|
||||
Log->println(("Querying lock state"));
|
||||
|
||||
while(result != Nuki::CmdResult::Success && retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Result (attempt "));
|
||||
Log->print(("Result (attempt "));
|
||||
Log->print(retryCount + 1);
|
||||
Log->print(F("): "));
|
||||
Log->print(("): "));
|
||||
result =_nukiLock.requestKeyTurnerState(&_keyTurnerState);
|
||||
++retryCount;
|
||||
}
|
||||
@@ -481,7 +485,7 @@ bool NukiWrapper::updateKeyTurnerState()
|
||||
postponeBleWatchdog();
|
||||
if(_retryLockstateCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Query lock state retrying in "));
|
||||
Log->print(("Query lock state retrying in "));
|
||||
Log->print(_retryDelay);
|
||||
Log->println("ms");
|
||||
_nextLockStateUpdateTs = espMillis() + _retryDelay;
|
||||
@@ -506,9 +510,9 @@ bool NukiWrapper::updateKeyTurnerState()
|
||||
{
|
||||
if(_publishAuthData && (lockState == NukiLock::LockState::Locked || lockState == NukiLock::LockState::Unlocked))
|
||||
{
|
||||
Log->println(F("Publishing auth data"));
|
||||
Log->println(("Publishing auth data"));
|
||||
updateAuthData(false);
|
||||
Log->println(F("Done publishing auth data"));
|
||||
Log->println(("Done publishing auth data"));
|
||||
}
|
||||
|
||||
updateGpioOutputs();
|
||||
@@ -516,7 +520,7 @@ bool NukiWrapper::updateKeyTurnerState()
|
||||
else if(!_nukiOfficial->getOffConnected() && espMillis() < _statusUpdatedTs + 10000)
|
||||
{
|
||||
updateStatus = true;
|
||||
Log->println(F("Lock: Keep updating status on intermediate lock state"));
|
||||
Log->println(("Lock: Keep updating status on intermediate lock state"));
|
||||
}
|
||||
|
||||
_network->publishKeyTurnerState(_keyTurnerState, _lastKeyTurnerState);
|
||||
@@ -526,7 +530,7 @@ bool NukiWrapper::updateKeyTurnerState()
|
||||
Log->println(lockStateStr);
|
||||
|
||||
postponeBleWatchdog();
|
||||
Log->println(F("Done querying lock state"));
|
||||
Log->println(("Done querying lock state"));
|
||||
return updateStatus;
|
||||
}
|
||||
|
||||
@@ -539,7 +543,7 @@ void NukiWrapper::updateBatteryState()
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Result (attempt "));
|
||||
Log->print(("Result (attempt "));
|
||||
Log->print(retryCount + 1);
|
||||
Log->print("): ");
|
||||
result = _nukiLock.requestBatteryReport(&_batteryReport);
|
||||
@@ -560,7 +564,7 @@ void NukiWrapper::updateBatteryState()
|
||||
_network->publishBatteryReport(_batteryReport);
|
||||
}
|
||||
postponeBleWatchdog();
|
||||
Log->println(F("Done querying lock battery state"));
|
||||
Log->println(("Done querying lock battery state"));
|
||||
}
|
||||
|
||||
void NukiWrapper::updateConfig()
|
||||
@@ -575,7 +579,7 @@ void NukiWrapper::updateConfig()
|
||||
{
|
||||
char uidString[20];
|
||||
itoa(_nukiConfig.nukiId, uidString, 16);
|
||||
Log->print(F("Saving Lock Nuki ID to preferences ("));
|
||||
Log->print(("Saving Lock Nuki ID to preferences ("));
|
||||
Log->print(_nukiConfig.nukiId);
|
||||
Log->print(" / ");
|
||||
Log->print(uidString);
|
||||
@@ -607,7 +611,7 @@ void NukiWrapper::updateConfig()
|
||||
{
|
||||
Nuki::CmdResult result = (Nuki::CmdResult)-1;
|
||||
int retryCount = 0;
|
||||
Log->println(F("Nuki Lock PIN is set"));
|
||||
Log->println(("Nuki Lock PIN is set"));
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
@@ -624,7 +628,7 @@ void NukiWrapper::updateConfig()
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
{
|
||||
Log->println(F("Nuki Lock PIN is invalid"));
|
||||
Log->println(("Nuki Lock PIN is invalid"));
|
||||
if(pinStatus != 2)
|
||||
{
|
||||
_preferences->putInt(preference_lock_pin_status, 2);
|
||||
@@ -632,7 +636,7 @@ void NukiWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Nuki Lock PIN is valid"));
|
||||
Log->println(("Nuki Lock PIN is valid"));
|
||||
if(pinStatus != 1)
|
||||
{
|
||||
_preferences->putInt(preference_lock_pin_status, 1);
|
||||
@@ -641,7 +645,7 @@ void NukiWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Nuki Lock PIN is not set"));
|
||||
Log->println(("Nuki Lock PIN is not set"));
|
||||
if(pinStatus != 0)
|
||||
{
|
||||
_preferences->putInt(preference_lock_pin_status, 0);
|
||||
@@ -650,13 +654,13 @@ void NukiWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Invalid/Unexpected lock config received, ID does not matched saved ID"));
|
||||
Log->println(("Invalid/Unexpected lock config received, ID does not matched saved ID"));
|
||||
expectedConfig = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Invalid/Unexpected lock config received, Config is not valid"));
|
||||
Log->println(("Invalid/Unexpected lock config received, Config is not valid"));
|
||||
expectedConfig = false;
|
||||
}
|
||||
|
||||
@@ -673,7 +677,7 @@ void NukiWrapper::updateConfig()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Invalid/Unexpected lock advanced config received, Advanced config is not valid"));
|
||||
Log->println(("Invalid/Unexpected lock advanced config received, Advanced config is not valid"));
|
||||
expectedConfig = false;
|
||||
}
|
||||
}
|
||||
@@ -681,12 +685,12 @@ void NukiWrapper::updateConfig()
|
||||
if(expectedConfig && _nukiConfigValid && _nukiAdvancedConfigValid)
|
||||
{
|
||||
_retryConfigCount = 0;
|
||||
Log->println(F("Done retrieving lock config and advanced config"));
|
||||
Log->println(("Done retrieving lock config and advanced config"));
|
||||
}
|
||||
else
|
||||
{
|
||||
++_retryConfigCount;
|
||||
Log->println(F("Invalid/Unexpected lock config and/or advanced config received, retrying in 10 seconds"));
|
||||
Log->println(("Invalid/Unexpected lock config and/or advanced config received, retrying in 10 seconds"));
|
||||
int64_t ts = espMillis();
|
||||
_nextConfigUpdateTs = ts + 10000;
|
||||
}
|
||||
@@ -696,7 +700,7 @@ void NukiWrapper::updateAuthData(bool retrieved)
|
||||
{
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Lock PIN set"));
|
||||
Log->println(("No valid Nuki Lock PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -707,7 +711,7 @@ void NukiWrapper::updateAuthData(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Retrieve log entries: "));
|
||||
Log->print(("Retrieve log entries: "));
|
||||
result = _nukiLock.retrieveLogEntries(0, _preferences->getInt(preference_authlog_max_entries, MAX_AUTHLOG), 1, false);
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
{
|
||||
@@ -759,7 +763,7 @@ void NukiWrapper::updateAuthData(bool retrieved)
|
||||
return a.index < b.index;
|
||||
});
|
||||
|
||||
Log->print(F("Log size: "));
|
||||
Log->print(("Log size: "));
|
||||
Log->println(log.size());
|
||||
|
||||
if(log.size() > 0)
|
||||
@@ -780,7 +784,7 @@ void NukiWrapper::updateKeypad(bool retrieved)
|
||||
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Lock PIN set"));
|
||||
Log->println(("No valid Nuki Lock PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -791,7 +795,7 @@ void NukiWrapper::updateKeypad(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Querying lock keypad: "));
|
||||
Log->print(("Querying lock keypad: "));
|
||||
result = _nukiLock.retrieveKeypadEntries(0, _preferences->getInt(preference_keypad_max_entries, MAX_KEYPAD));
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
{
|
||||
@@ -814,7 +818,7 @@ void NukiWrapper::updateKeypad(bool retrieved)
|
||||
std::list<NukiLock::KeypadEntry> entries;
|
||||
_nukiLock.getKeypadEntries(&entries);
|
||||
|
||||
Log->print(F("Lock keypad codes: "));
|
||||
Log->print(("Lock keypad codes: "));
|
||||
Log->println(entries.size());
|
||||
|
||||
entries.sort([](const NukiLock::KeypadEntry& a, const NukiLock::KeypadEntry& b)
|
||||
@@ -859,7 +863,7 @@ void NukiWrapper::updateTimeControl(bool retrieved)
|
||||
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Lock PIN set"));
|
||||
Log->println(("No valid Nuki Lock PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -870,7 +874,7 @@ void NukiWrapper::updateTimeControl(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries + 1)
|
||||
{
|
||||
Log->print(F("Querying lock timecontrol: "));
|
||||
Log->print(("Querying lock timecontrol: "));
|
||||
result = _nukiLock.retrieveTimeControlEntries();
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
{
|
||||
@@ -893,7 +897,7 @@ void NukiWrapper::updateTimeControl(bool retrieved)
|
||||
std::list<NukiLock::TimeControlEntry> timeControlEntries;
|
||||
_nukiLock.getTimeControlEntries(&timeControlEntries);
|
||||
|
||||
Log->print(F("Lock timecontrol entries: "));
|
||||
Log->print(("Lock timecontrol entries: "));
|
||||
Log->println(timeControlEntries.size());
|
||||
|
||||
timeControlEntries.sort([](const NukiLock::TimeControlEntry& a, const NukiLock::TimeControlEntry& b)
|
||||
@@ -930,7 +934,7 @@ void NukiWrapper::updateAuth(bool retrieved)
|
||||
{
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid Nuki Lock PIN set"));
|
||||
Log->println(("No valid Nuki Lock PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -946,7 +950,7 @@ void NukiWrapper::updateAuth(bool retrieved)
|
||||
|
||||
while(retryCount < _nrOfRetries)
|
||||
{
|
||||
Log->print(F("Querying lock authorization: "));
|
||||
Log->print(("Querying lock authorization: "));
|
||||
result = _nukiLock.retrieveAuthorizationEntries(0, _preferences->getInt(preference_auth_max_entries, MAX_AUTH));
|
||||
delay(250);
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -970,7 +974,7 @@ void NukiWrapper::updateAuth(bool retrieved)
|
||||
std::list<NukiLock::AuthorizationEntry> authEntries;
|
||||
_nukiLock.getAuthorizationEntries(&authEntries);
|
||||
|
||||
Log->print(F("Lock authorization entries: "));
|
||||
Log->print(("Lock authorization entries: "));
|
||||
Log->println(authEntries.size());
|
||||
|
||||
authEntries.sort([](const NukiLock::AuthorizationEntry& a, const NukiLock::AuthorizationEntry& b)
|
||||
@@ -1091,8 +1095,11 @@ LockActionResult NukiWrapper::onLockActionReceived(const char *value)
|
||||
{
|
||||
if(_preferences->getBool(preference_official_hybrid_actions, false))
|
||||
{
|
||||
_nukiOfficial->setOffCommandExecutedTs(espMillis() + 2000);
|
||||
_offCommand = action;
|
||||
if(_preferences->getBool(preference_official_hybrid_retry, false))
|
||||
{
|
||||
_nukiOfficial->setOffCommandExecutedTs(espMillis() + 2000);
|
||||
_offCommand = action;
|
||||
}
|
||||
_network->publishOffAction((int)action);
|
||||
}
|
||||
else
|
||||
@@ -2495,7 +2502,7 @@ void NukiWrapper::onKeypadCommandReceived(const char *command, const uint &id, c
|
||||
return;
|
||||
}
|
||||
|
||||
if(!_hasKeypad)
|
||||
if(!hasKeypad())
|
||||
{
|
||||
if(_nukiConfigValid)
|
||||
{
|
||||
@@ -2635,7 +2642,7 @@ void NukiWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
return;
|
||||
}
|
||||
|
||||
if(!_hasKeypad)
|
||||
if(!hasKeypad())
|
||||
{
|
||||
if(_nukiConfigValid)
|
||||
{
|
||||
@@ -2757,7 +2764,7 @@ void NukiWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
{
|
||||
auto it1 = std::find(_keypadCodeIds.begin(), _keypadCodeIds.end(), codeId);
|
||||
int index = it1 - _keypadCodeIds.begin();
|
||||
Log->print(F("Check keypad code: "));
|
||||
Log->print(("Check keypad code: "));
|
||||
|
||||
if(code == _keypadCodes[index])
|
||||
{
|
||||
@@ -2797,7 +2804,7 @@ void NukiWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
if(idExists)
|
||||
{
|
||||
result = _nukiLock.deleteKeypadEntry(codeId);
|
||||
Log->print(F("Delete keypad code: "));
|
||||
Log->print(("Delete keypad code: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else
|
||||
@@ -3004,7 +3011,7 @@ void NukiWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
}
|
||||
|
||||
result = _nukiLock.addKeypadEntry(entry);
|
||||
Log->print(F("Add keypad code: "));
|
||||
Log->print(("Add keypad code: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else if (strcmp(action, "update") == 0)
|
||||
@@ -3170,7 +3177,7 @@ void NukiWrapper::onKeypadJsonCommandReceived(const char *value)
|
||||
}
|
||||
|
||||
result = _nukiLock.updateKeypadEntry(entry);
|
||||
Log->print(F("Update keypad code: "));
|
||||
Log->print(("Update keypad code: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
}
|
||||
@@ -3297,7 +3304,7 @@ void NukiWrapper::onTimeControlCommandReceived(const char *value)
|
||||
if(idExists)
|
||||
{
|
||||
result = _nukiLock.removeTimeControlEntry(entryId);
|
||||
Log->print(F("Delete timecontrol: "));
|
||||
Log->print(("Delete timecontrol: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else
|
||||
@@ -3377,7 +3384,7 @@ void NukiWrapper::onTimeControlCommandReceived(const char *value)
|
||||
entry.lockAction = timeControlLockAction;
|
||||
|
||||
result = _nukiLock.addTimeControlEntry(entry);
|
||||
Log->print(F("Add timecontrol: "));
|
||||
Log->print(("Add timecontrol: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else if (strcmp(action, "update") == 0)
|
||||
@@ -3455,7 +3462,7 @@ void NukiWrapper::onTimeControlCommandReceived(const char *value)
|
||||
entry.lockAction = timeControlLockAction;
|
||||
|
||||
result = _nukiLock.updateTimeControlEntry(entry);
|
||||
Log->print(F("Update timecontrol: "));
|
||||
Log->print(("Update timecontrol: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
}
|
||||
@@ -3610,7 +3617,7 @@ void NukiWrapper::onAuthCommandReceived(const char *value)
|
||||
{
|
||||
result = _nukiLock.deleteAuthorizationEntry(authId);
|
||||
delay(250);
|
||||
Log->print(F("Delete authorization: "));
|
||||
Log->print(("Delete authorization: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else
|
||||
@@ -3830,7 +3837,7 @@ void NukiWrapper::onAuthCommandReceived(const char *value)
|
||||
|
||||
result = _nukiLock.addAuthorizationEntry(entry);
|
||||
delay(250);
|
||||
Log->print(F("Add authorization: "));
|
||||
Log->print(("Add authorization: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
else if (strcmp(action, "update") == 0)
|
||||
@@ -3996,7 +4003,7 @@ void NukiWrapper::onAuthCommandReceived(const char *value)
|
||||
|
||||
result = _nukiLock.updateAuthorizationEntry(entry);
|
||||
delay(250);
|
||||
Log->print(F("Update authorization: "));
|
||||
Log->print(("Update authorization: "));
|
||||
Log->println((int)result);
|
||||
}
|
||||
}
|
||||
@@ -4045,7 +4052,7 @@ const bool NukiWrapper::isPaired() const
|
||||
|
||||
const bool NukiWrapper::hasKeypad() const
|
||||
{
|
||||
return _forceKeypad || _hasKeypad;
|
||||
return (_forceKeypad || _hasKeypad);
|
||||
}
|
||||
|
||||
void NukiWrapper::notify(Nuki::EventType eventType)
|
||||
@@ -4100,7 +4107,7 @@ void NukiWrapper::readConfig()
|
||||
|
||||
char resultStr[20];
|
||||
NukiLock::cmdResultToString(result, resultStr);
|
||||
Log->print(F("Lock config result: "));
|
||||
Log->print(("Lock config result: "));
|
||||
Log->println(resultStr);
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -4128,7 +4135,7 @@ void NukiWrapper::readAdvancedConfig()
|
||||
|
||||
char resultStr[20];
|
||||
NukiLock::cmdResultToString(result, resultStr);
|
||||
Log->print(F("Lock advanced config result: "));
|
||||
Log->print(("Lock advanced config result: "));
|
||||
Log->println(resultStr);
|
||||
|
||||
if(result != Nuki::CmdResult::Success)
|
||||
@@ -4146,10 +4153,10 @@ void NukiWrapper::readAdvancedConfig()
|
||||
|
||||
bool NukiWrapper::hasDoorSensor() const
|
||||
{
|
||||
return _forceDoorsensor ||
|
||||
return (_forceDoorsensor ||
|
||||
_keyTurnerState.doorSensorState == Nuki::DoorSensorState::DoorClosed ||
|
||||
_keyTurnerState.doorSensorState == Nuki::DoorSensorState::DoorOpened ||
|
||||
_keyTurnerState.doorSensorState == Nuki::DoorSensorState::Calibrating;
|
||||
_keyTurnerState.doorSensorState == Nuki::DoorSensorState::Calibrating);
|
||||
}
|
||||
|
||||
const BLEAddress NukiWrapper::getBleAddress() const
|
||||
@@ -4208,7 +4215,7 @@ void NukiWrapper::updateTime()
|
||||
{
|
||||
if(!isPinValid())
|
||||
{
|
||||
Log->println(F("No valid PIN set"));
|
||||
Log->println(("No valid PIN set"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -4219,7 +4226,7 @@ void NukiWrapper::updateTime()
|
||||
|
||||
if (int(tm.tm_year + 1900) < int(2025))
|
||||
{
|
||||
Log->println(F("NTP Time not valid, not updating Nuki device"));
|
||||
Log->println(("NTP Time not valid, not updating Nuki device"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -4236,6 +4243,6 @@ void NukiWrapper::updateTime()
|
||||
char resultStr[15] = {0};
|
||||
NukiLock::cmdResultToString(cmdResult, resultStr);
|
||||
|
||||
Log->print(F("Lock time update result: "));
|
||||
Log->print(("Lock time update result: "));
|
||||
Log->println(resultStr);
|
||||
}
|
||||
@@ -19,7 +19,7 @@ public:
|
||||
|
||||
void initialize();
|
||||
void readSettings();
|
||||
void update();
|
||||
void update(bool reboot = false);
|
||||
|
||||
void lock();
|
||||
void unlock();
|
||||
|
||||
@@ -83,7 +83,7 @@
|
||||
#define preference_authlog_max_entries (char*)"authmaxentry"
|
||||
#define preference_keypad_max_entries (char*)"kpmaxentry"
|
||||
#define preference_timecontrol_max_entries (char*)"tcmaxentry"
|
||||
#define preference_register_as_app (char*)"regAsApp" // true = register as hub; false = register as app
|
||||
#define preference_register_as_app (char*)"regAsApp"
|
||||
#define preference_register_opener_as_app (char*)"regOpnAsApp"
|
||||
#define preference_acl (char*)"aclLckOpn"
|
||||
#define preference_conf_lock_basic_acl (char*)"confLckBasAcl"
|
||||
@@ -124,6 +124,7 @@
|
||||
#define preference_lock_force_keypad (char*)"lckForceKp"
|
||||
#define preference_opener_force_id (char*)"opForceId"
|
||||
#define preference_opener_force_keypad (char*)"opForceKp"
|
||||
#define preference_hybrid_reboot_on_disconnect (char*)"hybridRbtLck"
|
||||
|
||||
//NOT USER CHANGABLE
|
||||
#define preference_updater_version (char*)"updVer"
|
||||
@@ -185,6 +186,7 @@ inline void initPreferences(Preferences* preferences)
|
||||
preferences->putBool(preference_official_hybrid_enabled, false);
|
||||
preferences->putBool(preference_official_hybrid_actions, false);
|
||||
preferences->putBool(preference_official_hybrid_retry, false);
|
||||
preferences->putBool(preference_hybrid_reboot_on_disconnect, false);
|
||||
preferences->putBool(preference_disable_non_json, false);
|
||||
preferences->putBool(preference_update_from_mqtt, false);
|
||||
preferences->putBool(preference_ip_dhcp_enabled, true);
|
||||
@@ -472,7 +474,7 @@ private:
|
||||
preference_lock_max_timecontrol_entry_count, preference_opener_max_timecontrol_entry_count, preference_enable_bootloop_reset, preference_mqtt_ca, preference_mqtt_crt,
|
||||
preference_mqtt_key, preference_mqtt_hass_discovery, preference_mqtt_hass_cu_url, preference_buffer_size, preference_ip_dhcp_enabled, preference_ip_address,
|
||||
preference_ip_subnet, preference_ip_gateway, preference_ip_dns_server, preference_network_hardware, preference_http_auth_type,
|
||||
preference_rssi_publish_interval, preference_hostname, preference_network_timeout, preference_restart_on_disconnect,
|
||||
preference_rssi_publish_interval, preference_hostname, preference_network_timeout, preference_restart_on_disconnect, preference_hybrid_reboot_on_disconnect,
|
||||
preference_restart_ble_beacon_lost, preference_query_interval_lockstate, preference_timecontrol_topic_per_entry, preference_keypad_topic_per_entry,
|
||||
preference_query_interval_configuration, preference_query_interval_battery, preference_query_interval_keypad, preference_keypad_control_enabled,
|
||||
preference_keypad_info_enabled, preference_keypad_publish_code, preference_timecontrol_control_enabled, preference_timecontrol_info_enabled, preference_conf_info_enabled,
|
||||
@@ -505,7 +507,8 @@ private:
|
||||
preference_auth_control_enabled, preference_auth_topic_per_entry, preference_auth_info_enabled, preference_webserial_enabled, preference_hass_device_discovery,
|
||||
preference_ntw_reconfigure, preference_keypad_check_code_enabled, preference_disable_network_not_connected, preference_find_best_rssi, preference_http_auth_type,
|
||||
preference_debug_connect, preference_debug_communication, preference_debug_readable_data, preference_debug_hex_data, preference_debug_command, preference_connect_mode,
|
||||
preference_lock_force_id, preference_lock_force_doorsensor, preference_lock_force_keypad, preference_opener_force_id, preference_opener_force_keypad, preference_mqtt_ssl_enabled
|
||||
preference_lock_force_id, preference_lock_force_doorsensor, preference_lock_force_keypad, preference_opener_force_id, preference_opener_force_keypad, preference_mqtt_ssl_enabled,
|
||||
preference_hybrid_reboot_on_disconnect
|
||||
};
|
||||
std::vector<char*> _bytePrefs =
|
||||
{
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
28
src/main.cpp
28
src/main.cpp
@@ -54,6 +54,7 @@ Gpio* gpio = nullptr;
|
||||
bool lockEnabled = false;
|
||||
bool openerEnabled = false;
|
||||
bool wifiConnected = false;
|
||||
bool rebootLock = false;
|
||||
|
||||
TaskHandle_t nukiTaskHandle = nullptr;
|
||||
|
||||
@@ -162,9 +163,9 @@ void setReroute()
|
||||
uint8_t checkPartition()
|
||||
{
|
||||
const esp_partition_t* running_partition = esp_ota_get_running_partition();
|
||||
Log->print(F("Partition size: "));
|
||||
Log->print(("Partition size: "));
|
||||
Log->println(running_partition->size);
|
||||
Log->print(F("Partition subtype: "));
|
||||
Log->print(("Partition subtype: "));
|
||||
Log->println(running_partition->subtype);
|
||||
|
||||
if(running_partition->size == 1966080)
|
||||
@@ -197,7 +198,7 @@ void networkTask(void *pvParameters)
|
||||
if(bootloopCounter > 0)
|
||||
{
|
||||
bootloopCounter = (int8_t)0;
|
||||
Log->println(F("Bootloop counter reset"));
|
||||
Log->println(("Bootloop counter reset"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -217,7 +218,7 @@ void networkTask(void *pvParameters)
|
||||
|
||||
if(connected && lockEnabled)
|
||||
{
|
||||
networkLock->update();
|
||||
rebootLock = networkLock->update();
|
||||
}
|
||||
|
||||
if(connected && openerEnabled)
|
||||
@@ -293,7 +294,8 @@ void nukiTask(void *pvParameters)
|
||||
|
||||
if(lockEnabled)
|
||||
{
|
||||
nuki->update();
|
||||
nuki->update(rebootLock);
|
||||
rebootLock = false;
|
||||
}
|
||||
if(openerEnabled)
|
||||
{
|
||||
@@ -330,12 +332,12 @@ void bootloopDetection()
|
||||
esp_reset_reason() == esp_reset_reason_t::ESP_RST_WDT)
|
||||
{
|
||||
bootloopCounter++;
|
||||
Log->print(F("Bootloop counter incremented: "));
|
||||
Log->print(("Bootloop counter incremented: "));
|
||||
Log->println(bootloopCounter);
|
||||
|
||||
if(bootloopCounter == 10)
|
||||
{
|
||||
Log->print(F("Bootloop detected."));
|
||||
Log->print(("Bootloop detected."));
|
||||
|
||||
preferences->putInt(preference_buffer_size, CHAR_BUFFER_SIZE);
|
||||
preferences->putInt(preference_task_size_network, NETWORK_TASK_SIZE);
|
||||
@@ -431,7 +433,7 @@ void otaTask(void *pvParameter)
|
||||
{
|
||||
.http_config = &config,
|
||||
};
|
||||
Log->print(F("Attempting to download update from "));
|
||||
Log->print(("Attempting to download update from "));
|
||||
Log->println(config.url);
|
||||
|
||||
int retryMax = 3;
|
||||
@@ -503,7 +505,7 @@ void setupTasks(bool ota)
|
||||
}
|
||||
|
||||
void cbSyncTime(struct timeval *tv) {
|
||||
Log->println(F("NTP time synched"));
|
||||
Log->println(("NTP time synched"));
|
||||
}
|
||||
|
||||
void setup()
|
||||
@@ -549,9 +551,9 @@ void setup()
|
||||
}
|
||||
|
||||
#ifdef NUKI_HUB_UPDATER
|
||||
Log->print(F("Nuki Hub OTA version "));
|
||||
Log->print(("Nuki Hub OTA version "));
|
||||
Log->println(NUKI_HUB_VERSION);
|
||||
Log->print(F("Nuki Hub OTA build "));
|
||||
Log->print(("Nuki Hub OTA build "));
|
||||
Log->println();
|
||||
|
||||
if(preferences->getString(preference_updater_version, "") != NUKI_HUB_VERSION)
|
||||
@@ -653,9 +655,9 @@ void setup()
|
||||
bootloopDetection();
|
||||
}
|
||||
|
||||
Log->print(F("Nuki Hub version "));
|
||||
Log->print(("Nuki Hub version "));
|
||||
Log->println(NUKI_HUB_VERSION);
|
||||
Log->print(F("Nuki Hub build "));
|
||||
Log->print(("Nuki Hub build "));
|
||||
Log->println(NUKI_HUB_BUILD);
|
||||
|
||||
uint32_t devIdOpener = preferences->getUInt(preference_device_id_opener);
|
||||
|
||||
@@ -72,7 +72,7 @@ void EthernetDevice::initialize()
|
||||
if(ethCriticalFailure)
|
||||
{
|
||||
ethCriticalFailure = false;
|
||||
Log->println(F("Failed to initialize ethernet hardware"));
|
||||
Log->println(("Failed to initialize ethernet hardware"));
|
||||
Log->println("Network device has a critical failure, enable fallback to Wi-Fi and reboot.");
|
||||
wifiFallback = true;
|
||||
delay(200);
|
||||
@@ -80,11 +80,11 @@ void EthernetDevice::initialize()
|
||||
return;
|
||||
}
|
||||
|
||||
Log->println(F("Init Ethernet"));
|
||||
Log->println(("Init Ethernet"));
|
||||
|
||||
if(_useSpi)
|
||||
{
|
||||
Log->println(F("Use SPI"));
|
||||
Log->println(("Use SPI"));
|
||||
ethCriticalFailure = true;
|
||||
SPI.begin(_spi_sck, _spi_miso, _spi_mosi);
|
||||
_hardwareInitialized = ETH.begin(_type, _phy_addr, _cs, _irq, _rst, SPI);
|
||||
@@ -93,7 +93,7 @@ void EthernetDevice::initialize()
|
||||
#ifdef CONFIG_IDF_TARGET_ESP32
|
||||
else
|
||||
{
|
||||
Log->println(F("Use RMII"));
|
||||
Log->println(("Use RMII"));
|
||||
|
||||
// Workaround for failing RMII initialization with pioarduino 3.1.0
|
||||
// Revoke all GPIO's some of them set by init PSRAM in IDF
|
||||
@@ -118,7 +118,7 @@ void EthernetDevice::initialize()
|
||||
|
||||
if(_hardwareInitialized)
|
||||
{
|
||||
Log->println(F("Ethernet hardware Initialized"));
|
||||
Log->println(("Ethernet hardware Initialized"));
|
||||
wifiFallback = false;
|
||||
|
||||
if(_useSpi && !_ipConfiguration->dhcpEnabled())
|
||||
@@ -133,7 +133,7 @@ void EthernetDevice::initialize()
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->println(F("Failed to initialize ethernet hardware"));
|
||||
Log->println(("Failed to initialize ethernet hardware"));
|
||||
Log->println("Network device has a critical failure, enable fallback to Wi-Fi and reboot.");
|
||||
wifiFallback = true;
|
||||
delay(200);
|
||||
@@ -150,7 +150,7 @@ void EthernetDevice::update()
|
||||
{
|
||||
if(_ipConfiguration->ipAddress() != ETH.localIP())
|
||||
{
|
||||
Log->println(F("ETH Set static IP"));
|
||||
Log->println(("ETH Set static IP"));
|
||||
ETH.config(_ipConfiguration->ipAddress(), _ipConfiguration->defaultGateway(), _ipConfiguration->subnet(), _ipConfiguration->dnsServer());
|
||||
_checkIpTs = espMillis() + 5000;
|
||||
return;
|
||||
|
||||
@@ -16,20 +16,20 @@ IPConfiguration::IPConfiguration(Preferences *preferences)
|
||||
_gateway.fromString(_preferences->getString(preference_ip_gateway, ""));
|
||||
_dnsServer.fromString(_preferences->getString(preference_ip_dns_server, ""));
|
||||
|
||||
Log->print(F("IP configuration: "));
|
||||
Log->print(("IP configuration: "));
|
||||
if(dhcpEnabled())
|
||||
{
|
||||
Log->println(F("DHCP"));
|
||||
Log->println(("DHCP"));
|
||||
}
|
||||
else
|
||||
{
|
||||
Log->print(F("IP address: "));
|
||||
Log->print(("IP address: "));
|
||||
Log->print(ipAddress());
|
||||
Log->print(F(", Subnet: "));
|
||||
Log->print((", Subnet: "));
|
||||
Log->print(subnet());
|
||||
Log->print(F(", Gateway: "));
|
||||
Log->print((", Gateway: "));
|
||||
Log->print(defaultGateway());
|
||||
Log->print(F(", DNS: "));
|
||||
Log->print((", DNS: "));
|
||||
Log->println(dnsServer());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32,7 +32,7 @@ void NetworkDevice::init()
|
||||
if(ca_cert.length() > 1)
|
||||
{
|
||||
_useEncryption = true;
|
||||
Log->println(F("MQTT over TLS."));
|
||||
Log->println(("MQTT over TLS."));
|
||||
_mqttClientSecure = new espMqttClientSecure(espMqttClientTypes::UseInternalTask::NO);
|
||||
_mqttClientSecure->setCACert(caDest);
|
||||
|
||||
@@ -57,7 +57,7 @@ void NetworkDevice::init()
|
||||
|
||||
if(cert.length() > 1 && key.length() > 1)
|
||||
{
|
||||
Log->println(F("MQTT with client certificate."));
|
||||
Log->println(("MQTT with client certificate."));
|
||||
_mqttClientSecure->setCertificate(certDest);
|
||||
_mqttClientSecure->setPrivateKey(keyDest);
|
||||
}
|
||||
@@ -69,7 +69,7 @@ void NetworkDevice::init()
|
||||
|
||||
if (!_useEncryption)
|
||||
{
|
||||
Log->println(F("MQTT without TLS."));
|
||||
Log->println(("MQTT without TLS."));
|
||||
_mqttClient = new espMqttClient(espMqttClientTypes::UseInternalTask::NO);
|
||||
}
|
||||
|
||||
|
||||
@@ -110,7 +110,7 @@ bool WifiDevice::connect()
|
||||
if (ssid == WiFi.SSID(i))
|
||||
{
|
||||
Log->println(String("Saved SSID ") + ssid + String(" found with RSSI: ") +
|
||||
String(WiFi.RSSI(i)) + String(F("(")) +
|
||||
String(WiFi.RSSI(i)) + String(("(")) +
|
||||
String(constrain((100.0 + WiFi.RSSI(i)) * 2, 0, 100)) +
|
||||
String(" %) and BSSID: ") + WiFi.BSSIDstr(i) +
|
||||
String(" and channel: ") + String(WiFi.channel(i)));
|
||||
@@ -136,7 +136,7 @@ bool WifiDevice::connect()
|
||||
else
|
||||
{
|
||||
Log->println(String("Trying to connect to SSID ") + ssid + String(" found with RSSI: ") +
|
||||
String(WiFi.RSSI(bestConnection)) + String(F("(")) +
|
||||
String(WiFi.RSSI(bestConnection)) + String(("(")) +
|
||||
String(constrain((100.0 + WiFi.RSSI(bestConnection)) * 2, 0, 100)) +
|
||||
String(" %) and BSSID: ") + WiFi.BSSIDstr(bestConnection) +
|
||||
String(" and channel: ") + String(WiFi.channel(bestConnection)));
|
||||
@@ -253,7 +253,7 @@ void WifiDevice::onWifiEvent(const WiFiEvent_t &event, const WiFiEventInfo_t &in
|
||||
for (int i = 0; i < _foundNetworks; i++)
|
||||
{
|
||||
Log->println(String("SSID ") + WiFi.SSID(i) + String(" found with RSSI: ") +
|
||||
String(WiFi.RSSI(i)) + String(F("(")) +
|
||||
String(WiFi.RSSI(i)) + String(("(")) +
|
||||
String(constrain((100.0 + WiFi.RSSI(i)) * 2, 0, 100)) +
|
||||
String(" %) and BSSID: ") + WiFi.BSSIDstr(i) +
|
||||
String(" and channel: ") + String(WiFi.channel(i)));
|
||||
|
||||
@@ -47,7 +47,7 @@ NetworkDeviceType NetworkUtil::GetDeviceTypeFromPreference(int hardwareDetect, i
|
||||
}
|
||||
break;
|
||||
default:
|
||||
Log->println(F("Unknown hardware selected, falling back to Wi-Fi."));
|
||||
Log->println(("Unknown hardware selected, falling back to Wi-Fi."));
|
||||
return NetworkDeviceType::WiFi;
|
||||
break;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user