123 lines
3.3 KiB
C++
123 lines
3.3 KiB
C++
#include "Nuki.h"
|
|
#include <FreeRTOS.h>
|
|
|
|
Nuki* nukiInst;
|
|
|
|
Nuki::Nuki(const std::string& name, uint32_t id, Network* network)
|
|
: _nukiBle(name, id),
|
|
_network(network)
|
|
{
|
|
nukiInst = this;
|
|
|
|
memset(&_lastKeyTurnerState, sizeof(KeyTurnerState), 0);
|
|
memset(&_keyTurnerState, sizeof(KeyTurnerState), 0);
|
|
|
|
network->setLockActionReceived(nukiInst->onLockActionReceived);
|
|
}
|
|
|
|
void Nuki::initialize()
|
|
{
|
|
_nukiBle.initialize();
|
|
}
|
|
|
|
void Nuki::update()
|
|
{
|
|
if (!_paired) {
|
|
Serial.println(F("Nuki start pairing"));
|
|
|
|
if (_nukiBle.pairNuki()) {
|
|
Serial.println(F("Nuki paired"));
|
|
_paired = true;
|
|
}
|
|
else
|
|
{
|
|
vTaskDelay( 200 / portTICK_PERIOD_MS);
|
|
return;
|
|
}
|
|
}
|
|
|
|
vTaskDelay( 100 / portTICK_PERIOD_MS);
|
|
_nukiBle.requestKeyTurnerState(&_keyTurnerState);
|
|
|
|
char str[20];
|
|
lockstateToString(_keyTurnerState.lockState, str);
|
|
Serial.print(F("Nuki lock state: "));
|
|
Serial.println(str);
|
|
|
|
if(_keyTurnerState.lockState != _lastKeyTurnerState.lockState)
|
|
{
|
|
_network->publishKeyTurnerState(str);
|
|
}
|
|
|
|
memcpy(&_lastKeyTurnerState, &_keyTurnerState, sizeof(KeyTurnerState));
|
|
|
|
vTaskDelay( 20000 / portTICK_PERIOD_MS);
|
|
}
|
|
|
|
void Nuki::lockstateToString(const LockState state, char* str)
|
|
{
|
|
switch(state)
|
|
{
|
|
case LockState::uncalibrated:
|
|
strcpy(str, "uncalibrated");
|
|
break;
|
|
case LockState::locked:
|
|
strcpy(str, "locked");
|
|
break;
|
|
case LockState::locking:
|
|
strcpy(str, "locking");
|
|
break;
|
|
case LockState::unlocked:
|
|
strcpy(str, "unlocked");
|
|
break;
|
|
case LockState::unlatched:
|
|
strcpy(str, "unlatched");
|
|
break;
|
|
case LockState::unlockedLnga:
|
|
strcpy(str, "unlockedLnga");
|
|
break;
|
|
case LockState::unlatching:
|
|
strcpy(str, "unlatching");
|
|
break;
|
|
case LockState::calibration:
|
|
strcpy(str, "calibration");
|
|
break;
|
|
case LockState::bootRun:
|
|
strcpy(str, "bootRun");
|
|
break;
|
|
case LockState::motorBlocked:
|
|
strcpy(str, "motorBlocked");
|
|
break;
|
|
default:
|
|
strcpy(str, "undefined");
|
|
break;
|
|
}
|
|
}
|
|
|
|
LockAction Nuki::lockActionToEnum(const char *str)
|
|
{
|
|
if(strcmp(str, "unlock") == 0) return LockAction::unlock;
|
|
else if(strcmp(str, "lock") == 0) return LockAction::lock;
|
|
else if(strcmp(str, "unlatch") == 0) return LockAction::unlatch;
|
|
else if(strcmp(str, "lockNgo") == 0) return LockAction::lockNgo;
|
|
else if(strcmp(str, "lockNgoUnlatch") == 0) return LockAction::lockNgoUnlatch;
|
|
else if(strcmp(str, "fullLock") == 0) return LockAction::fullLock;
|
|
else if(strcmp(str, "fobAction2") == 0) return LockAction::fobAction2;
|
|
else if(strcmp(str, "fobAction1") == 0) return LockAction::fobAction1;
|
|
else if(strcmp(str, "fobAction3") == 0) return LockAction::fobAction3;
|
|
return (LockAction)0xff;
|
|
}
|
|
|
|
|
|
void Nuki::onLockActionReceived(const char *value)
|
|
{
|
|
LockAction action = nukiInst->lockActionToEnum(value);
|
|
Serial.print("Action: ");
|
|
Serial.println((int)action);
|
|
if(action != (LockAction)0xff)
|
|
{
|
|
// nukiInst->_nukiBle.lockAction(action, 0, 0);
|
|
vTaskDelay( 5000 / portTICK_PERIOD_MS);
|
|
}
|
|
}
|