From 356d7de2cfbe325322d0f4d10cd44494025b64c4 Mon Sep 17 00:00:00 2001
From: BotoX <github@botox.bz>
Date: Tue, 6 Jun 2023 19:34:45 +0200
Subject: [PATCH] first commit

---
 Makefile                     |   9 +
 app/FingerLogic.cpp          | 598 +++++++++++++++++++++++++++++++++++
 app/FingerLogic.h            | 105 ++++++
 app/FingerPrint.cpp          | 267 ++++++++++++++++
 app/FingerPrint.h            | 163 ++++++++++
 app/FingerPrint_API.cpp      | 101 ++++++
 app/FingerPrint_AsyncAPI.cpp | 510 +++++++++++++++++++++++++++++
 app/Settings.cpp             | 118 +++++++
 app/Settings.h               |  38 +++
 app/application.cpp          |  54 ++++
 app/main.cpp                 | 462 +++++++++++++++++++++++++++
 app/main.h                   |  65 ++++
 app/utils.cpp                |  75 +++++
 app/utils.h                  |   8 +
 component.mk                 |   4 +
 files/.gitkeep               |   0
 files/bootstrap.min.css.gz   | Bin 0 -> 18466 bytes
 files/bootstrap.min.js.gz    | Bin 0 -> 12913 bytes
 files/favicon.ico            | Bin 0 -> 1150 bytes
 files/index.html             |  25 ++
 files/jquery-3.2.1.min.js.gz | Bin 0 -> 29995 bytes
 files/main.css.gz            | Bin 0 -> 653 bytes
 files/main.js.gz             | Bin 0 -> 742 bytes
 files/nunjucks.min.js.gz     | Bin 0 -> 22603 bytes
 files/popper.min.js.gz       | Bin 0 -> 6963 bytes
 files/settings.conf          |  25 ++
 files/templates.js.gz        | Bin 0 -> 4065 bytes
 files/wifi-sprites.png       | Bin 0 -> 1815 bytes
 out/.gitignore               |   2 +
 29 files changed, 2629 insertions(+)
 create mode 100644 Makefile
 create mode 100644 app/FingerLogic.cpp
 create mode 100644 app/FingerLogic.h
 create mode 100644 app/FingerPrint.cpp
 create mode 100644 app/FingerPrint.h
 create mode 100644 app/FingerPrint_API.cpp
 create mode 100644 app/FingerPrint_AsyncAPI.cpp
 create mode 100644 app/Settings.cpp
 create mode 100644 app/Settings.h
 create mode 100644 app/application.cpp
 create mode 100644 app/main.cpp
 create mode 100644 app/main.h
 create mode 100644 app/utils.cpp
 create mode 100644 app/utils.h
 create mode 100644 component.mk
 create mode 100644 files/.gitkeep
 create mode 100644 files/bootstrap.min.css.gz
 create mode 100644 files/bootstrap.min.js.gz
 create mode 100644 files/favicon.ico
 create mode 100644 files/index.html
 create mode 100644 files/jquery-3.2.1.min.js.gz
 create mode 100644 files/main.css.gz
 create mode 100644 files/main.js.gz
 create mode 100644 files/nunjucks.min.js.gz
 create mode 100644 files/popper.min.js.gz
 create mode 100644 files/settings.conf
 create mode 100644 files/templates.js.gz
 create mode 100644 files/wifi-sprites.png
 create mode 100644 out/.gitignore

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ff51b6c
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,9 @@
+#####################################################################
+#### Please don't change this file. Use component.mk instead ####
+#####################################################################
+
+ifndef SMING_HOME
+$(error SMING_HOME is not set: please configure it as an environment variable)
+endif
+
+include $(SMING_HOME)/project.mk
diff --git a/app/FingerLogic.cpp b/app/FingerLogic.cpp
new file mode 100644
index 0000000..c0ac909
--- /dev/null
+++ b/app/FingerLogic.cpp
@@ -0,0 +1,598 @@
+#include <SmingCore.h>
+#include <Crypto/Sha2.h>
+#include "utils.h"
+#include "main.h"
+#include "FingerPrint.h"
+#include "FingerLogic.h"
+
+CFingerLogic::CFingerLogic(CMain *pMain)
+{
+	m_pFingerPrint = NULL;
+	m_State = STATE_INITIAL;
+	m_Finger = false;
+	m_Power = false;
+	m_pMain = pMain;
+
+	memset(&m_FingerParams, 0, sizeof(m_FingerParams));
+	memset(m_aFingerSlots, 0, sizeof(m_aFingerSlots));
+	m_FingerSlotsAdded = 0;
+
+	m_PowerOffTimer.initializeMs(1000, TimerDelegate(&CFingerLogic::PowerOff, this));
+}
+
+void CFingerLogic::Init(CFingerPrint *pFingerPrint)
+{
+	m_pFingerPrint = pFingerPrint;
+
+	InitFinger();
+}
+
+void CFingerLogic::SetState(FingerLogicState state)
+{
+	m_State = state;
+
+	if(m_State == STATE_READY || m_State == STATE_ERROR)
+		m_PowerOffTimer.start(false);
+	else
+	{
+		m_PowerOffTimer.stop();
+		PowerOn();
+	}
+}
+
+void CFingerLogic::PowerOff()
+{
+	if(!m_Power)
+		return;
+
+	debugf("PowerOff()");
+	m_Power = false;
+	Main().FingerEnable(false);
+	wifi_set_sleep_type(LIGHT_SLEEP_T);
+	system_soft_wdt_feed();
+}
+
+void CFingerLogic::PowerOn()
+{
+	if(m_Power)
+		return;
+
+	debugf("PowerOn()");
+	m_Power = true;
+	Main().FingerEnable(true);
+	wifi_set_sleep_type(MODEM_SLEEP_T);
+	delayMilliseconds(100);
+}
+
+void CFingerLogic::OnFingerInterrupt(bool finger)
+{
+	debugf("OnFingerInterrupt: %s", finger ? "DOWN" : "UP");
+	m_Finger = finger;
+
+	if(finger)
+	{
+		if(m_State == STATE_READY)
+			VerifyFinger();
+		else if(m_State == STATE_ENROLL_WAITFINGER1 || m_State == STATE_ENROLL_WAITFINGER2)
+			EnrollFinger_OnFinger();
+	}
+}
+
+bool CFingerLogic::FingerSlot(uint16_t index)
+{
+	if(index > m_FingerSlotsAdded)
+		return false;
+
+	return m_aFingerSlots[index / 8] & (1 << (index % 8));
+}
+
+bool CFingerLogic::FingerSlot(uint16_t index, bool value)
+{
+	if(index > m_FingerSlotsAdded)
+		return false;
+
+	if(value)
+		m_aFingerSlots[index / 8] |= (1 << (index % 8));
+	else
+		m_aFingerSlots[index / 8] &= ~(1 << (index % 8));
+	return true;
+}
+
+int CFingerLogic::FirstFreeFingerSlot()
+{
+	for(int i = 0; i < m_FingerSlotsAdded / 8; i++)
+	{
+		if(m_aFingerSlots[i] != 0xFF)
+		{
+			uint8_t val = m_aFingerSlots[i];
+			for(int j = 0; j < 8; j++)
+			{
+				if(!(val & (1 << j)))
+					return (i * 8) + j;
+			}
+		}
+	}
+
+	return -1;
+}
+
+
+void CFingerLogic::InitFinger()
+{
+	if(m_State > STATE_INIT_VERIFYPASSWORD)
+		return;
+
+	SetState(STATE_INIT_VERIFYPASSWORD);
+	FingerPrint().AsyncVerifyPassword((VerifyPasswordCallback)InitFinger_OnVerifyPassword, this);
+
+	m_Timer.initializeMs(100, TimerDelegate(&CFingerLogic::InitFinger, this)).start();
+}
+
+void CFingerLogic::InitFinger_OnVerifyPassword(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	pThis->m_Timer.stop();
+	debugf("InitFinger_OnVerifyPassword: (%d) %s", error, errorStr);
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_INIT_READSYSTEMPARAMETERS);
+		pThis->FingerPrint().AsyncReadSystemParameters((ReadSystemParametersCallback)InitFinger_OnReadSystemParameters, pThis);
+	}
+	else
+		pThis->SetState(STATE_ERROR);
+}
+
+void CFingerLogic::InitFinger_OnReadSystemParameters(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, CFingerSystemParameters *param)
+{
+	debugf("InitFinger_OnReadSystemParameters: (%d) %s", error, errorStr);
+
+	if(error == ERROR_OK)
+	{
+		memcpy(&pThis->m_FingerParams, param, sizeof(CFingerSystemParameters));
+		debugf("statusRegister: %d", param->statusRegister);
+		debugf("systemID: %d", param->systemID);
+		debugf("storageCapacity: %d", param->storageCapacity);
+		debugf("securityLevel: %d", param->securityLevel);
+		debugf("deviceAddress: %X", param->deviceAddress);
+		debugf("packetLength: %d", param->packetLength);
+		debugf("baudRate: %d", param->baudRate);
+
+		pThis->SetState(STATE_INIT_READTEMPLATEMAP);
+		pThis->FingerPrint().AsyncReadTemplateMap((ReadTemplateMapCallback)InitFinger_OnReadTemplateMap, pThis, 0);
+	}
+	else
+		pThis->SetState(STATE_ERROR);
+}
+
+void CFingerLogic::InitFinger_OnReadTemplateMap(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, uint8_t *pData, uint16_t dataLen)
+{
+	debugf("InitFinger_OnReadTemplateMap: (%d) %s (%p, %d)", error, errorStr, pData, dataLen);
+
+	if(error == ERROR_OK)
+	{
+		memcpy(&pThis->m_aFingerSlots[pThis->m_FingerSlotsAdded/8], pData, dataLen);
+		pThis->m_FingerSlotsAdded += dataLen * 8;
+
+		if(pThis->m_FingerSlotsAdded < pThis->m_FingerParams.storageCapacity)
+		{
+			uint8_t page = pThis->m_FingerSlotsAdded / 8 / dataLen;
+			pThis->FingerPrint().AsyncReadTemplateMap((ReadTemplateMapCallback)InitFinger_OnReadTemplateMap, pThis, page);
+		}
+		else
+		{
+			pThis->InitFinger_VerifyTemplates();
+		}
+	}
+}
+
+void CFingerLogic::InitFinger_VerifyTemplates()
+{
+	SetState(STATE_INIT_VERIFYTEMPLATES);
+
+	HashMap<uint16_t, CSettings::CFingerPrint> &fingerMap = Main().Settings().m_FingerPrints;
+	uint16_t fingerCount = fingerMap.count();
+
+	// Check consistency (1)
+	for(uint16_t i = 0; i < fingerCount; i++)
+	{
+		uint16_t id = fingerMap.keyAt(i);
+		if(!FingerSlot(id))
+		{
+			SetState(STATE_ERROR);
+			FingerPrint().EmptyDatabase();
+			fingerMap.clear();
+			Main().Settings().Save();
+			debugf("InitFinger_VerifyTemplates: INCONSITENCY(1) AT SLOT %d !!!", id);
+			return;
+		}
+	}
+
+	// Check consistency (2)
+	for(uint16_t id = 0; id < m_FingerSlotsAdded; id++)
+	{
+		if(FingerSlot(id) && !fingerMap.contains(id))
+		{
+			SetState(STATE_ERROR);
+			FingerPrint().EmptyDatabase();
+			fingerMap.clear();
+			Main().Settings().Save();
+			debugf("InitFinger_VerifyTemplates: INCONSITENCY(2) AT SLOT %d !!!", id);
+			return;
+		}
+	}
+
+	if(!fingerCount)
+	{
+		SetState(STATE_READY);
+		return;
+	}
+
+	m_iBuffer = 0;
+	uint16_t position = fingerMap.keyAt(m_iBuffer);
+	FingerPrint().AsyncLoadTemplate((LoadTemplateCallback)InitFinger_OnLoadTemplate, this, position, 0x01);
+}
+
+void CFingerLogic::InitFinger_OnLoadTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("InitFinger_OnLoadTemplate: (%d) %s", error, errorStr);
+
+	if(error == ERROR_OK)
+	{
+		pThis->FingerPrint().AsyncDownloadCharacteristics((DownloadCharacteristicsCallback)InitFinger_OnDownloadCharacteristics, pThis, 0x01);
+	}
+	else
+		pThis->SetState(STATE_ERROR);
+}
+
+void CFingerLogic::InitFinger_OnDownloadCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen)
+{
+	debugf("InitFinger_OnDownloadCharacteristics: (%d) %s (%p, %d)", error, errorStr, pChar, charLen);
+
+	if(error == ERROR_OK)
+	{
+		Crypto::Sha256 ctx;
+		ctx.update(pChar, charLen);
+		uint8_t *digest = ctx.getHash().data();
+
+		const CSettings::CFingerPrint &finger = pThis->Main().Settings().m_FingerPrints.valueAt(pThis->m_iBuffer);
+
+		char aHexDigest1[SHA256_SIZE*2+1];
+		char aHexDigest2[SHA256_SIZE*2+1];
+		bytes2hex(digest, sizeof(digest), aHexDigest1, sizeof(aHexDigest1));
+		bytes2hex(finger.m_aDigest, sizeof(finger.m_aDigest), aHexDigest2, sizeof(aHexDigest2));
+
+		debugf("Index: %d -> Num: %d \"%s\" (%s ?= %s)", pThis->m_iBuffer, finger.m_FingerNum, finger.m_aLabel, aHexDigest1, aHexDigest2);
+
+		if(memcmp(digest, finger.m_aDigest, SHA256_SIZE) != 0)
+		{
+			pThis->SetState(STATE_ERROR);
+			debugf("InitFinger_VerifyTemplates: DIVERGENT DIGEST AT SLOT %d !!!", pThis->m_iBuffer);
+			return;
+		}
+
+		pThis->m_iBuffer++;
+		if(pThis->m_iBuffer >= pThis->Main().Settings().m_FingerPrints.count())
+		{
+			debugf("InitFinger_VerifyTemplates: DONE! Verified %d templates.", pThis->m_iBuffer);
+			pThis->SetState(STATE_READY);
+			return;
+		}
+
+		uint16_t position = pThis->Main().Settings().m_FingerPrints.keyAt(pThis->m_iBuffer);
+		pThis->FingerPrint().AsyncLoadTemplate((LoadTemplateCallback)InitFinger_OnLoadTemplate, pThis, position, 0x01);
+	}
+	else
+		pThis->SetState(STATE_ERROR);
+}
+
+
+void CFingerLogic::VerifyFinger()
+{
+	if(m_State != STATE_READY)
+		return;
+
+	SetState(STATE_VERIFY_READIMAGE);
+	FingerPrint().AsyncReadImage((ReadImageCallback)VerifyFinger_OnReadImage, this);
+}
+
+void CFingerLogic::VerifyFinger_OnReadImage(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("VerifyFinger_OnReadImage: (%d) %s", error, errorStr);
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_VERIFY_CONVERTIMAGE);
+		pThis->FingerPrint().AsyncConvertImage((ConvertImageCallback)VerifyFinger_OnConvertImage, pThis, 0x01);
+	}
+	else
+	{
+		pThis->SetState(STATE_READY);
+		if(pThis->m_Finger)
+			pThis->VerifyFinger();
+	}
+}
+
+void CFingerLogic::VerifyFinger_OnConvertImage(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("VerifyFinger_OnConvertImage: (%d) %s", error, errorStr);
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_VERIFY_SEARCHTEMPLATE);
+		pThis->FingerPrint().AsyncSearchTemplate((SearchTemplateCallback)VerifyFinger_OnSearchTemplate, pThis, 0x01, 0, pThis->m_FingerParams.storageCapacity);
+	}
+	else
+	{
+		pThis->SetState(STATE_READY);
+		if(pThis->m_Finger)
+			pThis->VerifyFinger();
+	}
+}
+
+void CFingerLogic::VerifyFinger_OnSearchTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int16_t position, int16_t score)
+{
+	debugf("VerifyFinger_OnSearchTemplate: (%d) %s (%d, %d)", error, errorStr, position, score);
+
+	if(error == ERROR_OK)
+	{
+		pThis->m_iBuffer = position;
+		pThis->SetState(STATE_VERIFY_LOADTEMPLATE);
+		pThis->FingerPrint().AsyncLoadTemplate((LoadTemplateCallback)VerifyFinger_OnLoadTemplate, pThis, position, 0x01);
+	}
+	else
+		pThis->SetState(STATE_READY);
+}
+
+void CFingerLogic::VerifyFinger_OnLoadTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("VerifyFinger_OnLoadTemplate: (%d) %s", error, errorStr);
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_VERIFY_DOWNLOADCHARACTERISTICS);
+		pThis->FingerPrint().AsyncDownloadCharacteristics((DownloadCharacteristicsCallback)VerifyFinger_OnDownloadCharacteristics, pThis, 0x01);
+	}
+	else
+		pThis->SetState(STATE_READY);
+}
+
+void CFingerLogic::VerifyFinger_OnDownloadCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen)
+{
+	debugf("VerifyFinger_OnDownloadCharacteristics: (%d) %s (%p, %d)", error, errorStr, pChar, charLen);
+
+	if(error == ERROR_OK)
+	{
+		Crypto::Sha256 ctx;
+		ctx.update(pChar, charLen);
+		uint8_t *digest = ctx.getHash().data();
+
+		char aHexDigest[SHA256_SIZE*2+1];
+		bytes2hex(digest, sizeof(digest), aHexDigest, sizeof(aHexDigest));
+
+		debugf("Finger hexdigest: %s", aHexDigest);
+
+		pThis->Main().OnFingerVerified(pThis->m_iBuffer, digest);
+	}
+
+	pThis->SetState(STATE_READY);
+}
+
+
+bool CFingerLogic::EnrollFinger(bool cancel)
+{
+	if(cancel)
+	{
+		if(m_State < STATE_ENROLL_WAITFINGER1 || m_State > STATE_ENROLL_DOWNLOADCHARACTERISTICS)
+			return false;
+
+		SetState(STATE_READY);
+		return true;
+	}
+
+	if(m_State != STATE_READY)
+		return false;
+
+	SetState(STATE_ENROLL_WAITFINGER1);
+	if(m_Finger)
+		EnrollFinger_OnFinger();
+
+	return true;
+}
+
+void CFingerLogic::EnrollFinger_OnFinger()
+{
+	if(m_State == STATE_ENROLL_WAITFINGER1)
+	{
+		SetState(STATE_ENROLL_READIMAGE1);
+		FingerPrint().AsyncReadImage((ReadImageCallback)EnrollFinger_OnReadImage1, this);
+	}
+	else if(m_State == STATE_ENROLL_WAITFINGER2)
+	{
+		SetState(STATE_ENROLL_READIMAGE2);
+		FingerPrint().AsyncReadImage((ReadImageCallback)EnrollFinger_OnReadImage2, this);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnReadImage1(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("EnrollFinger_OnReadImage1: (%d) %s", error, errorStr);
+	if(pThis->m_State != STATE_ENROLL_READIMAGE1) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_CONVERTIMAGE1);
+		pThis->FingerPrint().AsyncConvertImage((ConvertImageCallback)EnrollFinger_OnConvertImage1, pThis, 0x01);
+	}
+	else
+	{
+		pThis->SetState(STATE_ENROLL_WAITFINGER1);
+		char aBuf[512];
+		m_snprintf(aBuf, sizeof(aBuf), "Error while scanning finger: %s<br>Lift your finger and try again.", errorStr);
+		pThis->Main().EnrollMessage(aBuf);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnConvertImage1(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("EnrollFinger_OnConvertImage1: (%d) %s", error, errorStr);
+	if(pThis->m_State != STATE_ENROLL_CONVERTIMAGE1) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_SEARCHTEMPLATE);
+		pThis->FingerPrint().AsyncSearchTemplate((SearchTemplateCallback)EnrollFinger_OnSearchTemplate, pThis, 0x01, 0, pThis->m_FingerParams.storageCapacity);
+	}
+	else
+	{
+		pThis->SetState(STATE_ENROLL_WAITFINGER1);
+		char aBuf[512];
+		m_snprintf(aBuf, sizeof(aBuf), "Error while analyzing finger: %s<br>Lift your finger and try again.", errorStr);
+		pThis->Main().EnrollMessage(aBuf);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnSearchTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int16_t position, int16_t score)
+{
+	debugf("EnrollFinger_OnSearchTemplate: (%d) %s (%d, %d)", error, errorStr, position, score);
+	if(pThis->m_State != STATE_ENROLL_SEARCHTEMPLATE) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_READY);
+		pThis->Main().EnrollMessage("Aborting: This finger is already enrolled!", true);
+	}
+	else
+	{
+		pThis->SetState(STATE_ENROLL_WAITFINGER2);
+		pThis->Main().EnrollMessage("Finger scanned. Lift finger and place it on the sensor again to enroll.");
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnReadImage2(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("EnrollFinger_OnReadImage2: (%d) %s", error, errorStr);
+	if(pThis->m_State != STATE_ENROLL_READIMAGE2) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_CONVERTIMAGE2);
+		pThis->FingerPrint().AsyncConvertImage((ConvertImageCallback)EnrollFinger_OnConvertImage2, pThis, 0x02);
+	}
+	else
+	{
+		pThis->SetState(STATE_ENROLL_WAITFINGER2);
+		char aBuf[512];
+		m_snprintf(aBuf, sizeof(aBuf), "Error while scanning finger: %s<br>Lift your finger and try again.", errorStr);
+		pThis->Main().EnrollMessage(aBuf);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnConvertImage2(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("EnrollFinger_OnConvertImage2: (%d) %s", error, errorStr);
+	if(pThis->m_State != STATE_ENROLL_CONVERTIMAGE2) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_COMPARE);
+		pThis->FingerPrint().AsyncCompareCharacteristics((CompareCharacteristicsCallback)EnrollFinger_OnCompareCharacteristics, pThis);
+	}
+	else
+	{
+		pThis->SetState(STATE_ENROLL_WAITFINGER2);
+		char aBuf[512];
+		m_snprintf(aBuf, sizeof(aBuf), "Error while analyzing finger: %s<br>Lift your finger and try again.", errorStr);
+		pThis->Main().EnrollMessage(aBuf);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnCompareCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int16_t score)
+{
+	debugf("EnrollFinger_OnCompareCharacteristics: (%d) %s (%d)", error, errorStr, score);
+	if(pThis->m_State != STATE_ENROLL_COMPARE) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_CREATETEMPLATE);
+		pThis->FingerPrint().AsyncCreateTemplate((CreateTemplateCallback)EnrollFinger_OnCreateTemplate, pThis);
+	}
+	else
+	{
+		pThis->SetState(STATE_ENROLL_WAITFINGER1);
+		char aBuf[512];
+		m_snprintf(aBuf, sizeof(aBuf), "Error while comparing fingers: %s<br>Lift your finger and try again.", errorStr);
+		pThis->Main().EnrollMessage(aBuf);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnCreateTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("EnrollFinger_OnCreateTemplate: (%d) %s", error, errorStr);
+	if(pThis->m_State != STATE_ENROLL_CREATETEMPLATE) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_STORETEMPLATE);
+		pThis->m_iBuffer = pThis->FirstFreeFingerSlot();
+		pThis->FingerPrint().AsyncStoreTemplate((StoreTemplateCallback)EnrollFinger_OnStoreTemplate, pThis, pThis->m_iBuffer, 0x01);
+	}
+	else
+	{
+		pThis->SetState(STATE_READY);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnStoreTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, uint16_t positionNumber)
+{
+	debugf("EnrollFinger_OnStoreTemplate: (%d) %s (%d)", error, errorStr, positionNumber);
+	if(pThis->m_State != STATE_ENROLL_STORETEMPLATE) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->FingerSlot(positionNumber, true);
+		pThis->SetState(STATE_ENROLL_LOADTEMPLATE);
+		pThis->FingerPrint().AsyncLoadTemplate((LoadTemplateCallback)EnrollFinger_OnLoadTemplate, pThis, positionNumber, 0x01);
+	}
+	else
+	{
+		pThis->SetState(STATE_READY);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnLoadTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr)
+{
+	debugf("EnrollFinger_OnLoadTemplate: (%d) %s", error, errorStr);
+	if(pThis->m_State != STATE_ENROLL_LOADTEMPLATE) return;
+
+	if(error == ERROR_OK)
+	{
+		pThis->SetState(STATE_ENROLL_DOWNLOADCHARACTERISTICS);
+		pThis->FingerPrint().AsyncDownloadCharacteristics((DownloadCharacteristicsCallback)EnrollFinger_OnDownloadCharacteristics, pThis, 0x01);
+	}
+	else
+	{
+		pThis->SetState(STATE_READY);
+	}
+}
+
+void CFingerLogic::EnrollFinger_OnDownloadCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen)
+{
+	debugf("EnrollFinger_OnDownloadCharacteristics: (%d) %s (%p, %d)", error, errorStr, pChar, charLen);
+	if(pThis->m_State != STATE_ENROLL_DOWNLOADCHARACTERISTICS) return;
+
+	if(error == ERROR_OK)
+	{
+		Crypto::Sha256 ctx;
+		ctx.update(pChar, charLen);
+		uint8_t *digest = ctx.getHash().data();
+
+		Serial1.printf("NEW Finger %d hexdigest: ", pThis->m_iBuffer);
+		for(uint8_t i = 0; i < sizeof(digest); i++)
+			Serial1.printf("%x", digest[i]);
+		Serial1.printf("\n");
+
+		pThis->Main().OnFingerEnrolled(pThis->m_iBuffer, digest);
+	}
+
+	pThis->SetState(STATE_READY);
+}
diff --git a/app/FingerLogic.h b/app/FingerLogic.h
new file mode 100644
index 0000000..ddc5081
--- /dev/null
+++ b/app/FingerLogic.h
@@ -0,0 +1,105 @@
+#ifndef FINGERLOGIC_H
+#define FINGERLOGIC_H
+
+#include <bitset>
+#include "FingerPrint.h"
+
+enum FingerLogicState
+{
+	STATE_ERROR = -1,
+	STATE_INITIAL = 0,
+
+	STATE_INIT_VERIFYPASSWORD,
+	STATE_INIT_READSYSTEMPARAMETERS,
+	STATE_INIT_READTEMPLATEMAP,
+	STATE_INIT_VERIFYTEMPLATES,
+
+	STATE_READY,
+
+	STATE_VERIFY_READIMAGE,
+	STATE_VERIFY_CONVERTIMAGE,
+	STATE_VERIFY_SEARCHTEMPLATE,
+	STATE_VERIFY_LOADTEMPLATE,
+	STATE_VERIFY_DOWNLOADCHARACTERISTICS,
+
+	STATE_ENROLL_WAITFINGER1,
+	STATE_ENROLL_READIMAGE1,
+	STATE_ENROLL_CONVERTIMAGE1,
+	STATE_ENROLL_SEARCHTEMPLATE,
+	STATE_ENROLL_WAITFINGER2,
+	STATE_ENROLL_READIMAGE2,
+	STATE_ENROLL_CONVERTIMAGE2,
+	STATE_ENROLL_COMPARE,
+	STATE_ENROLL_CREATETEMPLATE,
+	STATE_ENROLL_STORETEMPLATE,
+	STATE_ENROLL_LOADTEMPLATE,
+	STATE_ENROLL_DOWNLOADCHARACTERISTICS
+};
+
+class CFingerLogic
+{
+public:
+	CFingerLogic(class CMain *pMain);
+	void Init(CFingerPrint *pFingerPrint);
+	void OnFingerInterrupt(bool finger);
+
+	bool FingerSlot(uint16_t index);
+	bool FingerSlot(uint16_t index, bool value);
+	int FirstFreeFingerSlot();
+
+	void InitFinger();
+	static void InitFinger_OnVerifyPassword(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void InitFinger_OnReadSystemParameters(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, CFingerSystemParameters *param);
+	static void InitFinger_OnGetTemplates(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void InitFinger_OnReadTemplateMap(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, uint8_t *pData, uint16_t dataLen);
+	void InitFinger_VerifyTemplates();
+	static void InitFinger_OnLoadTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void InitFinger_OnDownloadCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen);
+
+	void VerifyFinger();
+	static void VerifyFinger_OnReadImage(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void VerifyFinger_OnConvertImage(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void VerifyFinger_OnSearchTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int16_t position, int16_t score);
+	static void VerifyFinger_OnLoadTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void VerifyFinger_OnDownloadCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen);
+
+	bool EnrollFinger(bool cancel=false);
+	static void EnrollFinger_OnReadImage1(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void EnrollFinger_OnConvertImage1(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void EnrollFinger_OnSearchTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int16_t position, int16_t score);
+	void EnrollFinger_OnFinger();
+	static void EnrollFinger_OnReadImage2(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void EnrollFinger_OnConvertImage2(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void EnrollFinger_OnCompareCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int16_t score);
+	static void EnrollFinger_OnCreateTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void EnrollFinger_OnStoreTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, uint16_t positionNumber);
+	static void EnrollFinger_OnLoadTemplate(CFingerLogic *pThis, FingerPrintError error, const char *errorStr);
+	static void EnrollFinger_OnDownloadCharacteristics(CFingerLogic *pThis, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen);
+
+	CMain &Main() { return *m_pMain; }
+	CFingerPrint &FingerPrint() { return *m_pFingerPrint; }
+
+private:
+	bool m_Power;
+	void PowerOff();
+	void PowerOn();
+	void SetState(FingerLogicState state);
+	Timer m_PowerOffTimer;
+
+	CMain *m_pMain;
+	CFingerPrint *m_pFingerPrint;
+	FingerLogicState m_State;
+	bool m_Finger;
+
+	CFingerSystemParameters m_FingerParams;
+	uint8_t m_aFingerSlots[1792/8];
+	uint16_t m_FingerSlotsAdded;
+
+	int32_t m_iBuffer;
+
+	Timer m_Timer;
+	void *m_fnUserCallback;
+	void *m_pUserData;
+};
+
+#endif
diff --git a/app/FingerPrint.cpp b/app/FingerPrint.cpp
new file mode 100644
index 0000000..5509565
--- /dev/null
+++ b/app/FingerPrint.cpp
@@ -0,0 +1,267 @@
+#include <SmingCore.h>
+#include "FingerPrint.h"
+
+static struct CFingerErrorsExplain
+{
+	uint8_t error;
+	const char *str;
+} gs_FingerErrors[] = {
+	{ERROR_OK,						"ERROR_OK: command execution complete"},
+	{ERROR_COMMUNICATION,			"ERROR_COMMUNICATION: error when receiving data package"},
+	{ERROR_NOFINGER,				"ERROR_NOFINGER: no finger on the sensor"},
+	{ERROR_READIMAGE,				"ERROR_READIMAGE: fail to enroll the finger"},
+	{ERROR_MESSYIMAGE,				"ERROR_MESSYIMAGE: fail to generate character file due to the over-disorderly fingerprint image"},
+	{ERROR_FEWFEATUREPOINTS,		"ERROR_FEWFEATUREPOINTS: fail to generate character file due to lackness of character point or over-smallness of fingerprint image"},
+	{ERROR_NOTMATCHING,				"ERROR_NOTMATCHING: finger doesn't match"},
+	{ERROR_NOTEMPLATEFOUND,			"ERROR_NOTEMPLATEFOUND: fail to find the matching finger"},
+	{ERROR_CHARACTERISTICSMISMATCH,	"ERROR_CHARACTERISTICSMISMATCH: fail to combine the character files"},
+	{ERROR_INVALIDPOSITION,			"ERROR_INVALIDPOSITION: addressing PageID is beyond the finger library"},
+	{ERROR_LOADTEMPLATE,			"ERROR_LOADTEMPLATE: error when reading template from library or the template is invalid"},
+	{ERROR_UPLOADTEMPLATE,			"ERROR_UPLOADTEMPLATE: error when uploading template"},
+	{ERROR_PACKETRESPONSEFAIL,		"ERROR_PACKETRESPONSEFAIL: Module can't receive the following data packages"},
+	{ERROR_UPLOADIMAGE,				"ERROR_UPLOADIMAGE: error when uploading image"},
+	{ERROR_DELETETEMPLATE,			"ERROR_DELETETEMPLATE: fail to delete the template"},
+	{ERROR_CLEARDATABASE,			"ERROR_CLEARDATABASE: fail to clear finger library"},
+	{ERROR_WRONGPASSWORD,			"ERROR_WRONGPASSWORD: wrong password"},
+	{ERROR_INVALIDIMAGE,			"ERROR_INVALIDIMAGE: fail to generate the image for the lackness of valid primary image"},
+	{ERROR_FLASH,					"ERROR_FLASH: error when writing flash"},
+	{ERROR_NODEF,					"ERROR_NODEF: No definition error"},
+	{ERROR_INVALIDREGISTER,			"ERROR_INVALIDREGISTER: invalid register number"},
+	{ERROR_INCORRECTREGISTERCONF,	"ERROR_INCORRECTREGISTERCONF: incorrect configuration of register"},
+	{ERROR_INVALIDNOTEPADPAGE,		"ERROR_INVALIDNOTEPADPAGE: wrong notepad page number"},
+	{ERROR_COMMUNICATIONPORT,		"ERROR_COMMUNICATIONPORT: fail to operate the communication port"}
+};
+
+const char *CFingerPrint::ExplainFingerError(uint8_t error)
+{
+	CFingerErrorsExplain *pFound = NULL;
+	for(int i = 0; i < sizeof(gs_FingerErrors) / sizeof(*gs_FingerErrors); i++)
+	{
+		if(error == gs_FingerErrors[i].error)
+		{
+			pFound = &gs_FingerErrors[i];
+			break;
+		}
+	}
+
+	if(pFound)
+		return pFound->str;
+
+	return "Unknown error.";
+}
+
+CFingerPrint::CFingerPrint()
+{
+	m_RecvState = RECV_DROP;
+}
+
+void CFingerPrint::Init(HardwareSerial &serial, uint32_t address, uint32_t password)
+{
+	if(m_pSerial)
+		return;
+
+	m_pSerial = &serial;
+	m_Address = address;
+	m_Password = password;
+
+	m_pSerial->onDataReceived(StreamDataReceivedDelegate(&CFingerPrint::OnData, this));
+}
+
+void CFingerPrint::OnData(Stream &stream, char arrivedChar, unsigned short availableCharsCount)
+{
+	if(m_RecvState == RECV_DONE)
+		return;
+
+	if(m_RecvState == RECV_DROP)
+	{
+		while(stream.available())
+			stream.read();
+
+		return;
+	}
+
+	// RECV_WAITING
+	while(stream.available())
+	{
+		uint8_t cur = stream.read();
+
+		if(m_RecvIndex == 0 && cur != 0xEF || m_RecvIndex == 1 && cur != 0x01)
+		{
+			debugf("skip garbage header at %d: %X", m_RecvIndex, cur);
+			m_RecvIndex = 0;
+			continue;
+		}
+
+		m_aRecvBuffer[m_RecvIndex++] = cur;
+
+		// Packet could be complete (the minimal packet size is 12 bytes)
+		if(m_RecvIndex >= 12)
+		{
+			// Check the packet header (redundant)
+			uint16_t header = m_aRecvBuffer[0] << 8 | m_aRecvBuffer[1];
+			if(header != 0xEF01)
+			{
+				debugf("wrong header: %X", header);
+				m_RecvIndex = 0;
+				continue;
+			}
+
+			// Calculate packet payload length
+			uint16_t length = m_aRecvBuffer[7] << 8 | m_aRecvBuffer[8];
+
+			// Check if the packet is still fully received
+			// Condition: index counter < packet payload length + packet frame
+			if(m_RecvIndex < length + 9)
+				continue;
+
+			// At this point the packet should be fully received
+			uint8_t ident = m_aRecvBuffer[6];
+
+			// Calculate checksum:
+			// Checksum = packet type (1 byte) + packet length RAW!! (2 bytes) + packet payload (n bytes)
+			uint16_t calcChecksum = ident;
+			const uint16_t tmp = 7 + length;
+			for(uint16_t i = 7; i < tmp; i++)
+				calcChecksum += m_aRecvBuffer[i];
+
+			// Checksum in received data package
+			uint16_t recvChecksum = m_aRecvBuffer[m_RecvIndex - 2] << 8 | m_aRecvBuffer[m_RecvIndex - 1];
+
+			if(calcChecksum != recvChecksum)
+			{
+				debugf("checksum!!: %X != %X", calcChecksum, recvChecksum);
+				m_RecvIndex = 0;
+				continue;
+			}
+
+			m_RecvIndex = 0;
+			m_RecvState = RECV_DONE;
+
+			(this->*m_fnRecvCallback)((FingerPrintIdent)ident, &m_aRecvBuffer[9], length - 2);
+		}
+	}
+}
+
+int CFingerPrint::Recv(FingerPrintIdent *pIdent, uint8_t *pData, uint16_t maxLength, const int maxTime)
+{
+	m_RecvState = RECV_DONE;
+	m_RecvIndex = 0;
+
+	debugf("Start manual recv:");
+	int Ret = -9999;
+
+	int timeout = maxTime;
+	while(true)
+	{
+		while(!m_pSerial->available())
+		{
+			if(--timeout == 0)
+				return Ret;
+			delay(1);
+		}
+
+		uint8_t cur = m_pSerial->read();
+		m_aRecvBuffer[m_RecvIndex++] = cur;
+
+		// Packet could be complete (the minimal packet size is 12 bytes)
+		if(m_RecvIndex >= 12)
+		{
+			// Check the packet header
+			uint16_t header = m_aRecvBuffer[0] << 8 | m_aRecvBuffer[1];
+			if(header != 0xEF01)
+			{
+				debugf("wrong header: %X", header);
+				m_RecvIndex = 0;
+				return Ret;
+			}
+
+			// Calculate packet payload length
+			uint16_t length = m_aRecvBuffer[7] << 8 | m_aRecvBuffer[8];
+
+			// Check if the packet is still fully received
+			// Condition: index counter < packet payload length + packet frame
+			if(m_RecvIndex < length + 9)
+				continue;
+
+			// At this point the packet should be fully received
+			uint8_t ident = m_aRecvBuffer[6];
+
+			// Calculate checksum:
+			// Checksum = packet type (1 byte) + packet length RAW! (2 bytes) + packet payload (n bytes)
+			uint16_t calcChecksum = ident + length;
+			uint16_t tmp = 9 + length - 2;
+			for(uint16_t i = 9; i < tmp; i++)
+				calcChecksum += m_aRecvBuffer[i];
+
+			// Checksum in received data package
+			uint16_t recvChecksum = m_aRecvBuffer[m_RecvIndex - 2] << 8 | m_aRecvBuffer[m_RecvIndex - 1];
+
+			if(calcChecksum != recvChecksum)
+			{
+				debugf("checksum!!: %X != %X", calcChecksum, recvChecksum);
+				m_RecvIndex = 0;
+				return Ret;
+			}
+
+			length -= 2;
+			Ret = 0;
+
+			if(pIdent)
+				*(uint8_t *)pIdent = ident;
+
+			if(pData)
+			{
+				memcpy(pData, &m_aRecvBuffer[9], min(length, maxLength));
+				Ret = (int)maxLength - length; // >= 0 = OK
+			}
+
+			break;
+		}
+	}
+
+	debugf("End recv. (%dms)", maxTime - timeout);
+	m_RecvIndex = 0;
+
+	return Ret;
+}
+
+int CFingerPrint::Write(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_WAITING;
+
+	// Header
+	const uint16_t Header = 0xEF01;
+	m_pSerial->write(Header >> 8 & 0xFF);
+	m_pSerial->write(Header >> 0 & 0xFF);
+
+	// Address
+	m_pSerial->write(m_Address >> 24 & 0xFF);
+	m_pSerial->write(m_Address >> 16 & 0xFF);
+	m_pSerial->write(m_Address >> 8 & 0xFF);
+	m_pSerial->write(m_Address >> 0 & 0xFF);
+
+	// Package identifier
+	m_pSerial->write(ident);
+
+	// Package length
+	length += 2; // Checksum
+	m_pSerial->write(length >> 8 & 0xFF);
+	m_pSerial->write(length >> 0 & 0xFF);
+
+	// Checksum
+	uint16_t Checksum = ident + length;
+
+	// Data
+	length -= 2;
+	for(uint16_t i = 0; i < length; i++)
+	{
+		m_pSerial->write(pData[i]);
+		Checksum += pData[i];
+	}
+
+	// Checksum
+	m_pSerial->write(Checksum >> 8 & 0xFF);
+	m_pSerial->write(Checksum >> 0 & 0xFF);
+
+	return length;
+}
diff --git a/app/FingerPrint.h b/app/FingerPrint.h
new file mode 100644
index 0000000..2bccf4b
--- /dev/null
+++ b/app/FingerPrint.h
@@ -0,0 +1,163 @@
+#ifndef FINGERPRINT_H
+#define FINGERPRINT_H
+
+// Data package identifier
+enum FingerPrintIdent
+{
+	IDENT_COMMAND			= 0x01, // Command packet
+	IDENT_DATA				= 0x02, // Data packet;
+									// Data packet shall not appear alone in executing processs,
+									// must follow command packet or acknowledge packet.
+	IDENT_ACK				= 0x07, // Acknowledge packet
+	IDENT_ENDOFDATA			= 0x08, // End of Data packet
+};
+
+enum FingerPrintCommand
+{
+	COMMAND_GENIMG			= 0x01, // Collect finger image
+	COMMAND_IMG2TZ			= 0x02, // To generate character file from image
+	COMMAND_MATCH			= 0x03, // Carry out precise matching of two templates
+	COMMAND_SEARCH			= 0x04, // Search library finger
+	COMMAND_REGMODEL		= 0x05, // To combine character files and generate template
+	COMMAND_STORE			= 0x06, // To store template;
+	COMMAND_LOADCHAR		= 0x07, // to read/load template
+	COMMAND_UPCHAR			= 0x08, // to upload template
+	COMMAND_DOWNCHR			= 0x09, // to download template
+	COMMAND_UPIMAGE			= 0x0A, // To upload image
+	COMMAND_DOWNIMAGE		= 0x0B, // To download image
+	COMMAND_DELETCHAR		= 0x0C, // to delete tempates
+	COMMAND_EMPTY			= 0x0D, // to empty the library
+	COMMAND_SETSYSPARA		= 0x0E, // To set system Parameter
+	COMMAND_READSYSPARA		= 0x0F, // To read Parameter
+	COMMAND_SETPWD			= 0x12, // To set password
+	COMMAND_VFYPWD			= 0x13, // To verify password
+	COMMAND_GETRANDOMCODE	= 0x14, // to get random code
+	COMMAND_SETADDER		= 0x15, // To set device address
+	COMMAND_CONTROL			= 0x17, // Port control
+	COMMAND_WRITENOTEPAD	= 0x18, // to write note pad
+	COMMAND_READNOTEPAD		= 0x19, // To read note pad
+	COMMAND_HISPEEDSEARCH	= 0x1B, // Search the library fastly
+	COMMAND_TEMPLATENUM		= 0x1D, // To read finger template numbers
+	COMMAND_READCONLIST		= 0x1F, // To read finger template index table
+};
+
+enum FingerPrintError
+{
+	ERROR_OK						= 0x00, // command execution complete
+	ERROR_COMMUNICATION				= 0x01, // error when receiving data package
+	ERROR_NOFINGER					= 0x02, // no finger on the sensor
+	ERROR_READIMAGE					= 0x03, // fail to enroll the finger
+	ERROR_MESSYIMAGE				= 0x06, // fail to generate character file due to the over-disorderly fingerprint image
+	ERROR_FEWFEATUREPOINTS			= 0x07, // fail to generate character file due to lackness of character point or over-smallness of fingerprint image
+	ERROR_NOTMATCHING				= 0x08, // finger doesn't match
+	ERROR_NOTEMPLATEFOUND			= 0x09, // fail to find the matching finger
+	ERROR_CHARACTERISTICSMISMATCH	= 0x0A, // fail to combine the character files
+	ERROR_INVALIDPOSITION			= 0x0B, // addressing PageID is beyond the finger library
+	ERROR_LOADTEMPLATE				= 0x0C, // error when reading template from library or the template is invalid
+	ERROR_UPLOADTEMPLATE			= 0x0D, // error when uploading template
+	ERROR_PACKETRESPONSEFAIL		= 0x0E, // Module can't receive the following data packages
+	ERROR_UPLOADIMAGE				= 0x0F, // error when uploading image
+	ERROR_DELETETEMPLATE			= 0x10, // fail to delete the template
+	ERROR_CLEARDATABASE				= 0x11, // fail to clear finger library
+	ERROR_WRONGPASSWORD				= 0x13, // wrong password
+	ERROR_INVALIDIMAGE				= 0x15, // fail to generate the image for the lackness of valid primary image
+	ERROR_FLASH						= 0x18, // error when writing flash
+	ERROR_NODEF						= 0x19, // No definition error
+	ERROR_INVALIDREGISTER			= 0x1A, // invalid register number
+	ERROR_INCORRECTREGISTERCONF		= 0x1B, // incorrect configuration of register
+	ERROR_INVALIDNOTEPADPAGE		= 0x1C, // wrong notepad page number
+	ERROR_COMMUNICATIONPORT			= 0x1D, // fail to operate the communication port
+};
+
+enum RecvStates
+{
+	RECV_DONE = 0,
+	RECV_WAITING = 1,
+	RECV_DROP = 2
+};
+
+struct CFingerSystemParameters
+{
+	uint16_t statusRegister;
+	uint16_t systemID;
+	uint16_t storageCapacity;
+	uint16_t securityLevel;
+	uint32_t deviceAddress;
+	uint16_t packetLength;
+	uint16_t baudRate;
+};
+
+class CFingerPrint;
+typedef void (CFingerPrint::*RecvCallback)(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+
+typedef void (*VerifyPasswordCallback)(void *pUser, FingerPrintError error, const char *errorStr);
+typedef void (*ReadSystemParametersCallback)(void *pUser, FingerPrintError error, const char *errorStr, CFingerSystemParameters *param);
+typedef void (*ReadImageCallback)(void *pUser, FingerPrintError error, const char *errorStr);
+typedef void (*ConvertImageCallback)(void *pUser, FingerPrintError error, const char *errorStr);
+typedef void (*SearchTemplateCallback)(void *pUser, FingerPrintError error, const char *errorStr, int16_t position, int16_t score);
+typedef void (*CompareCharacteristicsCallback)(void *pUser, FingerPrintError error, const char *errorStr, int16_t score);
+typedef void (*CreateTemplateCallback)(void *pUser, FingerPrintError error, const char *errorStr);
+typedef void (*DownloadCharacteristicsCallback)(void *pUser, FingerPrintError error, const char *errorStr, int8_t *pChar, uint16_t charLen);
+typedef void (*LoadTemplateCallback)(void *pUser, FingerPrintError error, const char *errorStr);
+typedef void (*StoreTemplateCallback)(void *pUser, FingerPrintError error, const char *errorStr, uint16_t positionNumber);
+typedef void (*ReadTemplateMapCallback)(void *pUser, FingerPrintError error, const char *errorStr, uint8_t *pData, uint16_t dataLen);
+
+class CFingerPrint
+{
+public:
+	CFingerPrint();
+	void Init(HardwareSerial &serial, uint32_t address, uint32_t password);
+
+	static const char *ExplainFingerError(uint8_t error);
+
+	int VerifyPassword();
+	int ReadSystemParameters(uint8_t aResponse[17]);
+	int DeleteTemplate(uint16_t positionStart, uint16_t count);
+	int EmptyDatabase();
+
+	int AsyncVerifyPassword(VerifyPasswordCallback fnCallback, void *pUser);
+	int AsyncReadSystemParameters(ReadSystemParametersCallback fnCallback, void *pUser);
+	int AsyncReadImage(ReadImageCallback fnCallback, void *pUser);
+	int AsyncConvertImage(ConvertImageCallback fnCallback, void *pUser, uint8_t numCharBuffer);
+	int AsyncSearchTemplate(SearchTemplateCallback fnCallback, void *pUser, uint8_t numCharBuffer, uint16_t positionStart, uint16_t numTemplates);
+	int AsyncCompareCharacteristics(CompareCharacteristicsCallback fnCallback, void *pUser);
+	int AsyncCreateTemplate(CreateTemplateCallback fnCallback, void *pUser);
+	int AsyncDownloadCharacteristics(DownloadCharacteristicsCallback fnCallback, void *pUser, uint8_t numCharBuffer);
+	int AsyncLoadTemplate(LoadTemplateCallback fnCallback, void *pUser, uint16_t positionNumber, uint8_t numCharBuffer);
+	int AsyncStoreTemplate(StoreTemplateCallback fnCallback, void *pUser, uint16_t positionNumber, uint8_t numCharBuffer);
+	int AsyncReadTemplateMap(ReadTemplateMapCallback fnCallback, void *pUser, uint8_t numPage);
+
+private:
+	void OnAsyncVerifyPassword(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncReadSystemParameters(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncReadImage(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncConvertImage(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncSearchTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncCompareCharacteristics(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncCreateTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncDownloadCharacteristics(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncLoadTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncStoreTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	void OnAsyncReadTemplateMap(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+
+	void OnData(Stream &stream, char arrivedChar, unsigned short availableCharsCount);
+	int Write(FingerPrintIdent ident, uint8_t *pData, uint16_t length);
+	int Recv(FingerPrintIdent *pIdent, uint8_t *pData, uint16_t maxLength, const int maxTime=100);
+
+	uint32_t m_Address;
+	uint32_t m_Password;
+	HardwareSerial *m_pSerial;
+
+	uint8_t m_aRecvBuffer[2+4+1+2+256+2];
+	uint16_t m_RecvIndex;
+
+	volatile RecvStates m_RecvState;
+	RecvCallback m_fnRecvCallback;
+	void *m_fnUserCallback;
+	void *m_pUserData;
+
+	uint8_t m_aBuffer[1024];
+	int32_t m_iBuffer;
+};
+
+#endif
diff --git a/app/FingerPrint_API.cpp b/app/FingerPrint_API.cpp
new file mode 100644
index 0000000..a2ab40b
--- /dev/null
+++ b/app/FingerPrint_API.cpp
@@ -0,0 +1,101 @@
+#include <SmingCore.h>
+#include "FingerPrint.h"
+
+int CFingerPrint::VerifyPassword()
+{
+	uint8_t aPayload[] = {
+		COMMAND_VFYPWD,
+		(uint8_t)(m_Password >> 24 & 0xFF),
+		(uint8_t)(m_Password >> 16 & 0xFF),
+		(uint8_t)(m_Password >> 8 & 0xFF),
+		(uint8_t)(m_Password >> 0 & 0xFF),
+	};
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	FingerPrintIdent ident;
+	uint8_t aResponse[1];
+	int ret = Recv(&ident, aResponse, sizeof(aResponse));
+	m_RecvState = RECV_DROP;
+
+	if(ret < 0)
+		return ret;
+
+	if(ident != IDENT_ACK)
+		return ERROR_COMMUNICATION;
+
+	uint8_t error = aResponse[0];
+	return error;
+}
+
+int CFingerPrint::ReadSystemParameters(uint8_t aResponse[17])
+{
+	uint8_t aPayload[] = {
+		COMMAND_READSYSPARA,
+	};
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	FingerPrintIdent ident;
+	int ret = Recv(&ident, aResponse, 17);
+	m_RecvState = RECV_DROP;
+
+	if(ret < 0)
+		return ret;
+
+	if(ident != IDENT_ACK)
+		return ERROR_COMMUNICATION;
+
+	uint8_t error = aResponse[0];
+	return error;
+}
+
+int CFingerPrint::DeleteTemplate(uint16_t positionStart, uint16_t count)
+{
+	uint8_t aPayload[] = {
+		COMMAND_DELETCHAR,
+		(uint8_t)(positionStart >> 8 & 0xFF),
+		(uint8_t)(positionStart >> 0 & 0xFF),
+		(uint8_t)(count >> 8 & 0xFF),
+		(uint8_t)(count >> 0 & 0xFF),
+	};
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	FingerPrintIdent ident;
+	uint8_t aResponse[1];
+	int ret = Recv(&ident, aResponse, sizeof(aResponse));
+	m_RecvState = RECV_DROP;
+
+	if(ret < 0)
+		return ret;
+
+	if(ident != IDENT_ACK)
+		return ERROR_COMMUNICATION;
+
+	uint8_t error = aResponse[0];
+	return error;
+}
+
+int CFingerPrint::EmptyDatabase()
+{
+	uint8_t aPayload[] = {
+		COMMAND_EMPTY,
+	};
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	FingerPrintIdent ident;
+	uint8_t aResponse[1];
+	int ret = Recv(&ident, aResponse, sizeof(aResponse));
+	m_RecvState = RECV_DROP;
+
+	if(ret < 0)
+		return ret;
+
+	if(ident != IDENT_ACK)
+		return ERROR_COMMUNICATION;
+
+	uint8_t error = aResponse[0];
+	return error;
+}
diff --git a/app/FingerPrint_AsyncAPI.cpp b/app/FingerPrint_AsyncAPI.cpp
new file mode 100644
index 0000000..8fcbe50
--- /dev/null
+++ b/app/FingerPrint_AsyncAPI.cpp
@@ -0,0 +1,510 @@
+#include <SmingCore.h>
+#include "FingerPrint.h"
+
+int CFingerPrint::AsyncVerifyPassword(VerifyPasswordCallback fnCallback, void *pUser)
+{
+	uint8_t aPayload[] = {
+		COMMAND_VFYPWD,
+		(uint8_t)(m_Password >> 24 & 0xFF),
+		(uint8_t)(m_Password >> 16 & 0xFF),
+		(uint8_t)(m_Password >> 8 & 0xFF),
+		(uint8_t)(m_Password >> 0 & 0xFF),
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncVerifyPassword;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncVerifyPassword(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((VerifyPasswordCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!");
+		return;
+	}
+
+	if(length != 1)
+	{
+		((VerifyPasswordCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!");
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	((VerifyPasswordCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr);
+}
+
+
+int CFingerPrint::AsyncReadSystemParameters(ReadSystemParametersCallback fnCallback, void *pUser)
+{
+	uint8_t aPayload[] = {
+		COMMAND_READSYSPARA,
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncReadSystemParameters;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncReadSystemParameters(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((ReadSystemParametersCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!", NULL);
+		return;
+	}
+
+	if(length != 1 + sizeof(CFingerSystemParameters))
+	{
+		((ReadSystemParametersCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!", NULL);
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	CFingerSystemParameters *param = (CFingerSystemParameters *)m_aBuffer;
+	param->statusRegister     = pData[1] << 8 | pData[2];
+	param->systemID           = pData[3] << 8 | pData[4];
+	param->storageCapacity    = pData[5] << 8 | pData[6];
+	param->securityLevel      = pData[7] << 8 | pData[8];
+	param->deviceAddress      = pData[9] << 24 | pData[10] << 16 | pData[11] << 8 | pData[12];
+	param->packetLength       = pData[13] << 8 | pData[14];
+	param->baudRate           = pData[15] << 8 | pData[16];
+
+	((ReadSystemParametersCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, param);
+}
+
+
+int CFingerPrint::AsyncReadImage(ReadImageCallback fnCallback, void *pUser)
+{
+	uint8_t aPayload[] = {
+		COMMAND_GENIMG,
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncReadImage;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncReadImage(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((ReadImageCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!");
+		return;
+	}
+
+	if(length != 1)
+	{
+		((ReadImageCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!");
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	((ReadImageCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr);
+}
+
+
+int CFingerPrint::AsyncConvertImage(ConvertImageCallback fnCallback, void *pUser, uint8_t numCharBuffer)
+{
+	if(numCharBuffer != 0x01 && numCharBuffer != 0x02)
+		return -1;
+
+	uint8_t aPayload[] = {
+		COMMAND_IMG2TZ,
+		numCharBuffer,
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncConvertImage;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncConvertImage(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((ConvertImageCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!");
+		return;
+	}
+
+	if(length != 1)
+	{
+		((ConvertImageCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!");
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	((ConvertImageCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr);
+}
+
+
+int CFingerPrint::AsyncSearchTemplate(SearchTemplateCallback fnCallback, void *pUser, uint8_t numCharBuffer, uint16_t positionStart, uint16_t numTemplates)
+{
+	if(numCharBuffer != 0x01 && numCharBuffer != 0x02)
+		return -1;
+
+	uint8_t aPayload[] = {
+		COMMAND_SEARCH,
+		numCharBuffer,
+		(uint8_t)(positionStart >> 8 & 0xFF),
+		(uint8_t)(positionStart >> 0 & 0xFF),
+		(uint8_t)(numTemplates >> 8 & 0xFF),
+		(uint8_t)(numTemplates >> 0 & 0xFF),
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncSearchTemplate;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncSearchTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	int16_t position = -1;
+	int16_t score = -1;
+
+	if(ident != IDENT_ACK)
+	{
+		((SearchTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!", position, score);
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	if(error == ERROR_OK)
+	{
+		if(length != 5)
+		{
+			((SearchTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!", position, score);
+			return;
+		}
+
+		position = pData[1] << 8 | pData[2];
+		score = pData[3] << 8 | pData[4];
+	}
+
+	((SearchTemplateCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, position, score);
+}
+
+
+int CFingerPrint::AsyncCompareCharacteristics(CompareCharacteristicsCallback fnCallback, void *pUser)
+{
+	uint8_t aPayload[] = {
+		COMMAND_MATCH,
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncCompareCharacteristics;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncCompareCharacteristics(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	int16_t score = -1;
+
+	if(ident != IDENT_ACK)
+	{
+		((CompareCharacteristicsCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!", score);
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	if(error == ERROR_OK)
+	{
+		if(length != 3)
+		{
+			((CompareCharacteristicsCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!", score);
+			return;
+		}
+
+		score = pData[1] << 8 | pData[2];
+	}
+
+	((CompareCharacteristicsCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, score);
+}
+
+
+int CFingerPrint::AsyncCreateTemplate(CreateTemplateCallback fnCallback, void *pUser)
+{
+	uint8_t aPayload[] = {
+		COMMAND_REGMODEL,
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncCreateTemplate;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncCreateTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((CreateTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!");
+		return;
+	}
+
+	if(length != 1)
+	{
+		((CreateTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!");
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	((CreateTemplateCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr);
+}
+
+
+int CFingerPrint::AsyncDownloadCharacteristics(DownloadCharacteristicsCallback fnCallback, void *pUser, uint8_t numCharBuffer)
+{
+	if(numCharBuffer != 0x01 && numCharBuffer != 0x02)
+		return -1;
+
+	uint8_t aPayload[] = {
+		COMMAND_UPCHAR,
+		numCharBuffer,
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncDownloadCharacteristics;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+	m_iBuffer = -1;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncDownloadCharacteristics(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	if(m_iBuffer == -1)
+	{
+		if(ident != IDENT_ACK)
+		{
+			m_RecvState = RECV_DROP;
+			((DownloadCharacteristicsCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!", NULL, 0);
+			return;
+		}
+
+		uint8_t error = pData[0];
+		const char *errorStr = ExplainFingerError(error);
+
+		if(error != ERROR_OK)
+		{
+			m_RecvState = RECV_DROP;
+			((DownloadCharacteristicsCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, NULL, 0);
+			return;
+		}
+
+		m_iBuffer = 0;
+		m_RecvState = RECV_WAITING;
+		return;
+	}
+
+	if(ident != IDENT_DATA && ident != IDENT_ENDOFDATA)
+	{
+		m_RecvState = RECV_DROP;
+		((DownloadCharacteristicsCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no data packet", NULL, 0);
+		return;
+	}
+
+	if(sizeof(m_aBuffer) - m_iBuffer < length)
+	{
+		m_RecvState = RECV_DROP;
+		((DownloadCharacteristicsCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Not enough space to store received data", NULL, 0);
+		return;
+	}
+
+	memcpy(&m_aBuffer[m_iBuffer], pData, length);
+	m_iBuffer += length;
+
+	if(ident == IDENT_ENDOFDATA)
+	{
+		m_RecvState = RECV_DROP;
+		((DownloadCharacteristicsCallback)m_fnUserCallback)(m_pUserData, ERROR_OK, ExplainFingerError(ERROR_OK), (int8_t *)m_aBuffer, m_iBuffer);
+		return;
+	}
+
+	m_RecvState = RECV_WAITING;
+}
+
+
+int CFingerPrint::AsyncLoadTemplate(LoadTemplateCallback fnCallback, void *pUser, uint16_t positionNumber, uint8_t numCharBuffer)
+{
+	if(numCharBuffer != 0x01 && numCharBuffer != 0x02)
+		return -1;
+
+	uint8_t aPayload[] = {
+		COMMAND_LOADCHAR,
+		numCharBuffer,
+		(uint8_t)(positionNumber >> 8 & 0xFF),
+		(uint8_t)(positionNumber >> 0 & 0xFF),
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncLoadTemplate;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncLoadTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((LoadTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!");
+		return;
+	}
+
+	if(length != 1)
+	{
+		((LoadTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!");
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	((LoadTemplateCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr);
+}
+
+
+int CFingerPrint::AsyncStoreTemplate(StoreTemplateCallback fnCallback, void *pUser, uint16_t positionNumber, uint8_t numCharBuffer)
+{
+	if(numCharBuffer != 0x01 && numCharBuffer != 0x02)
+		return -1;
+
+	uint8_t aPayload[] = {
+		COMMAND_STORE,
+		numCharBuffer,
+		(uint8_t)(positionNumber >> 8 & 0xFF),
+		(uint8_t)(positionNumber >> 0 & 0xFF),
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncStoreTemplate;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+	m_iBuffer = positionNumber;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncStoreTemplate(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((StoreTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!", m_iBuffer);
+		return;
+	}
+
+	if(length != 1)
+	{
+		((StoreTemplateCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "Incorrect data length!", m_iBuffer);
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	((StoreTemplateCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, m_iBuffer);
+}
+
+
+int CFingerPrint::AsyncReadTemplateMap(ReadTemplateMapCallback fnCallback, void *pUser, uint8_t numPage)
+{
+	uint8_t aPayload[] = {
+		COMMAND_READCONLIST,
+		numPage
+	};
+
+	m_fnRecvCallback = &CFingerPrint::OnAsyncReadTemplateMap;
+	m_fnUserCallback = (void *)fnCallback;
+	m_pUserData = pUser;
+
+	Write(IDENT_COMMAND, aPayload, sizeof(aPayload));
+
+	return 0;
+}
+
+void CFingerPrint::OnAsyncReadTemplateMap(FingerPrintIdent ident, uint8_t *pData, uint16_t length)
+{
+	m_RecvState = RECV_DROP;
+
+	if(ident != IDENT_ACK)
+	{
+		((ReadTemplateMapCallback)m_fnUserCallback)(m_pUserData, ERROR_COMMUNICATION, "The received packet is no ack packet!", NULL, 0);
+		return;
+	}
+
+	uint8_t error = pData[0];
+	const char *errorStr = ExplainFingerError(error);
+
+	if(error != ERROR_OK)
+	{
+		((ReadTemplateMapCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, NULL, 0);
+		return;
+	}
+
+	((ReadTemplateMapCallback)m_fnUserCallback)(m_pUserData, (FingerPrintError)error, errorStr, &pData[1], length - 1);
+}
diff --git a/app/Settings.cpp b/app/Settings.cpp
new file mode 100644
index 0000000..4a7fa0d
--- /dev/null
+++ b/app/Settings.cpp
@@ -0,0 +1,118 @@
+#include <SmingCore.h>
+#include <ArduinoJson.h>
+#include "utils.h"
+#include "Settings.h"
+
+CSettings::CSettings()
+{
+	strcpy(m_aUsername, "admin");
+	strcpy(m_aPassword, "admin");
+	strcpy(m_aSSID, "");
+	strcpy(m_aPSK, "");
+	m_DHCP = true;
+	strcpy(m_aHostname, "safeweb");
+	m_Address = IPAddress(0, 0, 0, 0);
+	m_Netmask = IPAddress(0, 0, 0, 0);
+	m_Gateway = IPAddress(0, 0, 0, 0);
+	memset(m_aLockCode, 0, sizeof(m_aLockCode));
+}
+
+bool CSettings::Exists()
+{
+	return fileExist(APP_SETTINGS_FILE);
+}
+
+bool CSettings::Load()
+{
+	if(!Exists())
+	{
+		Save();
+		return true;
+	}
+
+	uint32_t size = fileGetSize(APP_SETTINGS_FILE);
+	char *pData = new char[size + 1];
+	fileGetContent(APP_SETTINGS_FILE, pData, size + 1);
+
+	DynamicJsonDocument doc(1024);
+	if(deserializeJson(doc, pData))
+	{
+		delete[] pData;
+		return false;
+	}
+
+	strncpy(m_aUsername, doc["username"], sizeof(m_aUsername));
+	strncpy(m_aPassword, doc["password"], sizeof(m_aPassword));
+
+	JsonObject network = doc["network"];
+	strncpy(m_aSSID, network["ssid"], sizeof(m_aSSID));
+	strncpy(m_aPSK, network["passphrase"], sizeof(m_aPSK));
+	m_DHCP = network["dhcp"];
+	strncpy(m_aHostname, network["hostname"], sizeof(m_aHostname));
+	m_Address = network["address"].as<const char *>();
+	m_Netmask = network["netmask"].as<const char *>();
+	m_Gateway = network["gateway"].as<const char *>();
+
+	JsonArray lockCode = doc["lock_code"];
+	uint8_t tmp = min(lockCode.size(), sizeof(m_aLockCode));
+	for(uint8_t i = 0; i < tmp; i++)
+		m_aLockCode[i] = lockCode[i];
+
+	JsonArray fingerprints = doc["fingerprints"];
+	uint16_t sz = fingerprints.size();
+	m_FingerPrints.allocate(sz);
+	for(uint16_t i = 0; i < sz; i++)
+	{
+		JsonObject obj = fingerprints[i];
+		CFingerPrint finger;
+
+		finger.m_FingerNum = obj["num"];
+		strncpy(finger.m_aLabel, obj["label"], sizeof(finger.m_aLabel));
+		hex2bytes(obj["digest"].as<const char *>(), finger.m_aDigest, sizeof(finger.m_aDigest));
+
+		m_FingerPrints[finger.m_FingerNum] = finger;
+	}
+
+	delete[] pData;
+	return true;
+}
+
+void CSettings::Save()
+{
+	DynamicJsonDocument doc(1024);
+
+	doc["username"] = m_aUsername;
+	doc["password"] = m_aPassword;
+
+	JsonObject network = doc.createNestedObject("network");
+	network["ssid"] = m_aSSID;
+	network["passphrase"] = m_aPSK;
+	network["dhcp"] = m_DHCP;
+	network["hostname"] = m_aHostname;
+	network["address"] = m_Address.toString();
+	network["netmask"] = m_Netmask.toString();
+	network["gateway"] = m_Gateway.toString();
+
+	JsonArray lockCode = doc.createNestedArray("lock_code");
+	for(uint8_t i = 0; i < sizeof(m_aLockCode); i++)
+		lockCode.add(m_aLockCode[i]);
+
+	JsonArray fingerprints = doc.createNestedArray("fingerprints");
+	uint16_t tmp = m_FingerPrints.count();
+	for(uint16_t i = 0; i < tmp; i++)
+	{
+		JsonObject obj = fingerprints.createNestedObject();
+		const CFingerPrint &finger = m_FingerPrints.valueAt(i);
+
+		obj["num"] = finger.m_FingerNum;
+		obj["label"] = String(finger.m_aLabel);
+
+		char aHexDigest[SHA256_SIZE*2+1];
+		bytes2hex(finger.m_aDigest, sizeof(finger.m_aDigest), aHexDigest, sizeof(aHexDigest));
+		obj["digest"] = String(aHexDigest);
+	}
+
+	String docString;
+	serializeJsonPretty(doc, docString);
+	fileSetContent(APP_SETTINGS_FILE, docString);
+}
diff --git a/app/Settings.h b/app/Settings.h
new file mode 100644
index 0000000..d5a71fb
--- /dev/null
+++ b/app/Settings.h
@@ -0,0 +1,38 @@
+#ifndef SETTINGS_H
+#define SETTINGS_H
+
+#define APP_SETTINGS_FILE "settings.conf"
+
+class CSettings
+{
+public:
+	CSettings();
+
+	bool Exists();
+	bool Load();
+	void Save();
+
+	char m_aUsername[32];
+	char m_aPassword[32];
+
+	char m_aSSID[32+1];
+	char m_aPSK[64+1];
+
+	bool m_DHCP;
+	char m_aHostname[64];
+	IpAddress m_Address;
+	IpAddress m_Netmask;
+	IpAddress m_Gateway;
+
+	uint8_t m_aLockCode[8];
+
+	struct CFingerPrint
+	{
+		uint16_t m_FingerNum;
+		char m_aLabel[32];
+		uint8_t m_aDigest[SHA256_SIZE];
+	};
+	HashMap<uint16_t, CFingerPrint> m_FingerPrints;
+};
+
+#endif
diff --git a/app/application.cpp b/app/application.cpp
new file mode 100644
index 0000000..7dc4bbb
--- /dev/null
+++ b/app/application.cpp
@@ -0,0 +1,54 @@
+#include <SmingCore.h>
+#include "FingerPrint.h"
+#include "main.h"
+
+HardwareSerial Serial1(UART_ID_1);
+NtpClient ntpClient("at.pool.ntp.org", 3600);
+
+void IRAM_ATTR OnFingerInterrupt()
+{
+	// LOW = FINGER, HIGH = NO FINGER
+	bool status = digitalRead(FINGER_DETECT_PIN);
+
+	g_Main.OnFingerInterrupt(!status);
+}
+
+void ready()
+{
+	debugf("READY!");
+
+	gpio_pin_wakeup_enable(GPIO_ID_PIN(FINGER_DETECT_PIN), GPIO_PIN_INTR_LOLEVEL);
+
+	g_Main.Init(Serial);
+
+	attachInterrupt(FINGER_DETECT_PIN, OnFingerInterrupt, CHANGE);
+}
+
+void init()
+{
+	// for fingerprint module
+	Serial.systemDebugOutput(false);
+	Serial.begin(115200, SERIAL_8N1, SERIAL_FULL);
+	Serial.flush(); // TODO: Full flush?
+
+	// for debug messages
+	Serial1.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY);
+	Serial1.systemDebugOutput(true);
+
+	// p-channel FET to turn on fingerprint module
+	pinMode(FINGER_ENABLE_PIN, OUTPUT_OPEN_DRAIN);
+	digitalWrite(FINGER_ENABLE_PIN, 1);
+
+	// communication with safe lock
+	pinMode(SAFELOCK_DATA_PIN, OUTPUT_OPEN_DRAIN);
+	digitalWrite(SAFELOCK_DATA_PIN, 1);
+
+	pinMode(FINGER_DETECT_PIN, INPUT);
+	pinMode(SAFELOCK_DETECT_PIN, INPUT);
+	pinMode(DOOR_DETECT_PIN, INPUT);
+
+	// mount spiffs
+	spiffs_mount();
+
+	System.onReady(ready);
+}
diff --git a/app/main.cpp b/app/main.cpp
new file mode 100644
index 0000000..3fd98fd
--- /dev/null
+++ b/app/main.cpp
@@ -0,0 +1,462 @@
+#include <SmingCore.h>
+#include <Data/WebHelpers/base64.h>
+#include <ArduinoJson.h>
+#include "utils.h"
+#include "main.h"
+
+CMain g_Main;
+
+CMain::CMain() : m_FingerLogic(this)
+{
+}
+
+static void STAGotIP(IpAddress ip, IpAddress mask, IpAddress gateway)
+{
+	debugf("GOTIP - IP: %s, MASK: %s, GW: %s\n", ip.toString().c_str(), mask.toString().c_str(),
+			gateway.toString().c_str());
+}
+
+static void STADisconnect(const String& ssid, MacAddress bssid, WifiDisconnectReason reason)
+{
+	debugf("DISCONNECT - SSID: %s, REASON: %d", ssid.c_str(), WifiEvents.getDisconnectReasonDesc(reason).c_str());
+}
+
+void CMain::Init(HardwareSerial &serial)
+{
+	m_Settings.Load();
+	//m_Settings.Save();
+
+	WifiAccessPoint.enable(false);
+	if(m_Settings.m_aSSID[0])
+	{
+		debugf("Station: %s", m_Settings.m_aSSID);
+		WifiStation.enable(true);
+		WifiStation.config(m_Settings.m_aSSID, m_Settings.m_aPSK);
+		if(m_Settings.m_DHCP && m_Settings.m_aHostname[0])
+			WifiStation.setHostname(m_Settings.m_aHostname);
+		if(!m_Settings.m_DHCP && !m_Settings.m_Address.isNull())
+			WifiStation.setIP(m_Settings.m_Address, m_Settings.m_Netmask, m_Settings.m_Gateway);
+		WifiStation.connect();
+	}
+	else
+	{
+		debugf("Access Point 'admin': %s", m_Settings.m_aPassword);
+		WifiAccessPoint.config("safeweb", m_Settings.m_aPassword, AUTH_WPA2_PSK);
+		WifiAccessPoint.enable(true);
+	}
+
+	WifiEvents.onStationGotIP(STAGotIP);
+	WifiEvents.onStationDisconnect(STADisconnect);
+
+	m_FTP.listen(21);
+	m_FTP.addUser(m_Settings.m_aUsername, m_Settings.m_aPassword);
+
+	m_HttpServer.listen(80);
+	m_HttpServer.setBodyParser("application/json", bodyToStringParser);
+
+	m_HttpServer.paths.set("/api", HttpPathDelegate(&CMain::HttpOnApi, this));
+	m_HttpServer.paths.set("/api/dashboard", HttpPathDelegate(&CMain::HttpOnApi, this));
+	m_HttpServer.paths.set("/api/fingerprint", HttpPathDelegate(&CMain::HttpOnApi, this));
+	m_HttpServer.paths.set("/api/fingerprint/label", HttpPathDelegate(&CMain::HttpOnApi, this));
+	m_HttpServer.paths.set("/api/fingerprint/delete", HttpPathDelegate(&CMain::HttpOnApi, this));
+	m_HttpServer.paths.set("/api/fingerprint/enroll", HttpPathDelegate(&CMain::HttpOnApi, this));
+	m_HttpServer.paths.set("/api/unlock", HttpPathDelegate(&CMain::HttpOnApi, this));
+
+	m_HttpServer.paths.setDefault(HttpPathDelegate(&CMain::HttpOnFile, this));
+
+	m_FingerPrint.Init(serial, 0xFFFFFFFF, 0x00000000);
+	m_FingerLogic.Init(&m_FingerPrint);
+}
+
+bool CMain::HttpAuthorized(HttpRequest &request, HttpResponse &response)
+{
+	String auth = request.getHeader("Authorization");
+	if(auth.startsWith("Basic "))
+	{
+		int headerLength = auth.length() - 6;
+		if(headerLength <= 64)
+		{
+			auth = base64_decode(auth.c_str() + 6, headerLength);
+			if(auth)
+			{
+				int sep = auth.indexOf(':');
+				if(sep != -1)
+				{
+					String username = auth.substring(0, sep);
+					String password = auth.substring(sep + 1);
+					if(username == m_Settings.m_aUsername && password == m_Settings.m_aPassword)
+						return true;
+				}
+			}
+		}
+	}
+
+	response.code = HTTP_STATUS_UNAUTHORIZED;
+	response.setHeader("WWW-Authenticate", "Basic realm=\"safeweb\"");
+	response.setHeader("401 Wrong credentials", "Authentication required");
+	response.setHeader("Connection", "close");
+	return false;
+}
+
+void CMain::HttpOnApi(HttpRequest &request, HttpResponse &response)
+{
+	if(!HttpAuthorized(request, response))
+		return;
+
+	String path = request.uri.Path;
+	if(path.length() < 6)
+	{
+		response.code = HTTP_STATUS_NOT_FOUND;
+		return;
+	}
+	String endpoint = path.substring(5);
+
+	DynamicJsonDocument jsonReq(1024);
+	deserializeJson(jsonReq, request.getBody());
+	DynamicJsonDocument jsonResp(1024);
+
+	response.setAllowCrossDomainOrigin("*");
+	response.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+	if(request.method == HTTP_OPTIONS)
+	{
+		response.code = HTTP_STATUS_OK;
+		return;
+	}
+
+
+	HttpStatus status = HandleApi(request.method, endpoint, jsonReq, jsonResp);
+	if(status != HTTP_STATUS_OK)
+	{
+		response.code = status;
+		return;
+	}
+
+	String respString;
+	serializeJson(jsonResp, respString);
+	response.setContentType(MIME_JSON);
+	response.sendString(respString);
+}
+
+HttpStatus CMain::HandleApi(HttpMethod method, String endpoint, JsonDocument &req, JsonDocument &resp)
+{
+	String test;
+	serializeJsonPretty(req, test);
+
+	debugf("request: %s\n", test.c_str());
+
+	if(endpoint == "dashboard")
+	{
+		if(method != HTTP_GET) return HTTP_STATUS_METHOD_NOT_ALLOWED;
+
+		JsonObject lock = resp.createNestedObject("lock");
+		lock["locked"] = true;
+
+		JsonObject door = resp.createNestedObject("door");
+		door["closed"] = true;
+
+		JsonObject battery = resp.createNestedObject("battery");
+		debugf("adc: %d\n", system_adc_read());
+		battery["voltage"] = (system_adc_read() / 1024.f) / 0.23;
+		battery["color"] = "success";
+		if(battery["voltage"] < 3.6f)
+			battery["color"] = "warning";
+
+		JsonObject network = resp.createNestedObject("network");
+		if(WifiStation.isEnabled())
+		{
+			network["type"] = "Station";
+			network["ssid"] = WifiStation.getSSID();
+			network["channel"] = WifiStation.getChannel();
+			network["dhcp"] = WifiStation.isEnabledDHCP();
+			network["rssi"] = WifiStation.getRssi();
+			network["signal"] = Rssi2Quality(WifiStation.getRssi());
+			network["address"] = WifiStation.getIP().toString();
+		}
+		else
+		{
+			network["type"] = "Access Point";
+			network["ssid"] = WifiAccessPoint.getSSID();
+			network["channel"] = WifiStation.getChannel();
+			network["dhcp"] = true;
+			network["address"] = WifiAccessPoint.getIP().toString();
+		}
+	}
+	else if(endpoint == "unlock")
+	{
+		if(method != HTTP_POST) return HTTP_STATUS_METHOD_NOT_ALLOWED;
+
+		LockUnlock();
+		resp["success"] = "true";
+	}
+	else if(endpoint == "fingerprint")
+	{
+		if(method != HTTP_GET) return HTTP_STATUS_METHOD_NOT_ALLOWED;
+
+		JsonArray fingerprints = resp.createNestedArray("fingerprints");
+		uint16_t tmp = Settings().m_FingerPrints.count();
+		for(uint16_t i = 0; i < tmp; i++)
+		{
+			JsonObject obj = fingerprints.createNestedObject();
+			const CSettings::CFingerPrint &finger = Settings().m_FingerPrints.valueAt(i);
+
+			obj["num"] = finger.m_FingerNum;
+			obj["label"] = String(finger.m_aLabel);
+
+			char aHexDigest[SHA256_SIZE*2+1];
+			bytes2hex(finger.m_aDigest, sizeof(finger.m_aDigest), aHexDigest, sizeof(aHexDigest));
+			obj["digest"] = String(aHexDigest);
+		}
+	}
+	else if(endpoint == "fingerprint/label")
+	{
+		if(method != HTTP_POST) return HTTP_STATUS_METHOD_NOT_ALLOWED;
+
+		if(!req.containsKey("index") || !req.containsKey("label"))
+			return HTTP_STATUS_BAD_REQUEST;
+
+		int index = req["index"].as<int>() - 1;
+		String label = req["label"];
+
+		if(index < 0 || index >= Settings().m_FingerPrints.count())
+			return HTTP_STATUS_BAD_REQUEST;
+
+		CSettings::CFingerPrint &finger = Settings().m_FingerPrints.valueAt(index);
+		strncpy(finger.m_aLabel, label.c_str(), sizeof(finger.m_aLabel));
+		Settings().Save();
+
+		resp["success"] = true;
+	}
+	else if(endpoint == "fingerprint/delete")
+	{
+		if(method != HTTP_POST) return HTTP_STATUS_METHOD_NOT_ALLOWED;
+
+		if(!req.containsKey("index"))
+			return HTTP_STATUS_BAD_REQUEST;
+
+		int index = req["index"].as<int>() - 1;
+
+		if(index < 0 || index >= Settings().m_FingerPrints.count())
+			return HTTP_STATUS_BAD_REQUEST;
+
+		const CSettings::CFingerPrint &finger = Settings().m_FingerPrints.valueAt(index);
+		FingerPrint().DeleteTemplate(finger.m_FingerNum, 1);
+		Settings().m_FingerPrints.removeAt(index);
+		Settings().Save();
+
+		resp["success"] = true;
+	}
+	else if(endpoint == "fingerprint/enroll")
+	{
+		if(method != HTTP_POST) return HTTP_STATUS_METHOD_NOT_ALLOWED;
+
+		if(req.containsKey("cancel"))
+		{
+			if(req["cancel"].as<bool>() && m_Enrolling)
+			{
+				resp["success"] = FingerLogic().EnrollFinger(false);
+				m_Enrolling = false;
+				m_Enrolled = false;
+			}
+		}
+		else
+		{
+			if(!req.containsKey("enrolling"))
+				return HTTP_STATUS_BAD_REQUEST;
+
+			bool enrolling = req["enrolling"];
+			if(enrolling && !m_Enrolling)
+			{
+				if(m_Enrolled)
+				{
+					resp["done"] = true;
+					resp["message"] = m_EnrollMessage;
+					m_Enrolled = false;
+				}
+				else
+				{
+					resp["error"] = m_EnrollMessage;
+				}
+			}
+			else if(enrolling && m_Enrolling)
+			{
+				resp["done"] = false;
+				resp["message"] = m_EnrollMessage;
+			}
+			else // if(!enrolling)
+			{
+				if(!req.containsKey("label"))
+					return HTTP_STATUS_BAD_REQUEST;
+
+				if(!m_Enrolling)
+				{
+					FingerLogic().EnrollFinger();
+					m_Enrolling = true;
+					m_Enrolled = false;
+					m_EnrollLabel = String(req["label"].as<const char *>());
+					resp["done"] = false;
+					m_EnrollMessage = "Started enroll process. Please place your finger on the sensor.";
+					resp["message"] = m_EnrollMessage;
+				}
+				else
+				{
+					resp["done"] = true;
+					m_Enrolled = false;
+					resp["message"] = m_EnrollMessage;
+				}
+			}
+		}
+	}
+	else
+	{
+		return HTTP_STATUS_NOT_FOUND;
+	}
+
+	return HTTP_STATUS_OK;
+}
+
+void CMain::HttpOnFile(HttpRequest &request, HttpResponse &response)
+{
+	if(!HttpAuthorized(request, response))
+		return;
+
+	String file = request.uri.Path;
+
+	if(file == "/")
+		file = "index.html";
+	if(file[0] == '/')
+		file = file.substring(1);
+	if(file[0] == '.')
+	{
+		response.code = HTTP_STATUS_FORBIDDEN;
+		return;
+	}
+
+	response.setCache(86400, true); // It's important to use cache for better performance.
+	response.sendFile(file);
+}
+
+void CMain::OnFingerInterrupt(bool finger)
+{
+	m_FingerLogic.OnFingerInterrupt(finger);
+}
+
+void CMain::FingerEnable(bool enable)
+{
+	const int pin = FINGER_ENABLE_PIN;
+	digitalWrite(pin, !enable);
+}
+
+void CMain::LockSendBytes(uint8_t *pBytes, uint8_t len)
+{
+	const int pin = SAFELOCK_DATA_PIN;
+
+	// Init
+	digitalWrite(pin, 0);
+	delayMicroseconds(10 * 1000);
+	digitalWrite(pin, 1);
+	delayMicroseconds(10 * 1000);
+
+	// Send data, calculate checksum and send checksum
+	uint8_t chk = 0x00;
+	for(uint8_t i = 0; i <= len; i++)
+	{
+		uint8_t byte;
+		if(i == len)
+		{
+			byte = chk;
+		}
+		else
+		{
+			byte = pBytes[i];
+			chk ^= byte;
+		}
+
+		for(int8_t j = 0; j < 8; j++)
+		{
+			digitalWrite(pin, 0);
+			delayMicroseconds(100);
+			digitalWrite(pin, 1);
+
+			uint8_t val = byte & (1 << j);
+			if(val)
+				delayMicroseconds(300);
+			else
+				delayMicroseconds(100);
+		}
+
+		digitalWrite(pin, 0);
+		delayMicroseconds(100);
+		digitalWrite(pin, 1);
+		delayMicroseconds(8);
+	}
+}
+
+void CMain::LockSendCode(uint8_t pass[8])
+{
+	uint8_t packet[9] = {0x51};
+	memcpy(&packet[1], pass, 8);
+	LockSendBytes(packet, sizeof(packet));
+}
+
+void CMain::LockUnlock()
+{
+	LockSendCode(Settings().m_aLockCode);
+}
+
+void CMain::EnrollMessage(const char *msg, bool error)
+{
+	m_EnrollMessage = msg;
+	if(error)
+		m_Enrolling = false;
+}
+
+void CMain::OnFingerVerified(uint16_t fingerNum, uint8_t digest[SHA256_SIZE])
+{
+	int fingerIndex = Settings().m_FingerPrints.indexOf(fingerNum);
+	if(fingerIndex == -1)
+	{
+		debugf("OnFingerVerified: fingerIndex == -1");
+		return;
+	}
+
+	const CSettings::CFingerPrint &finger = Settings().m_FingerPrints.valueAt(fingerIndex);
+	if(memcmp(digest, finger.m_aDigest, SHA256_SIZE) != 0)
+	{
+		debugf("OnFingerVerified: SHA256 mismatch");
+		return;
+	}
+
+	LockUnlock();
+
+	debugf("OnFingerVerified: OK!!!");
+}
+
+void CMain::OnFingerEnrolled(uint16_t fingerNum, uint8_t digest[SHA256_SIZE])
+{
+	CSettings::CFingerPrint finger;
+	finger.m_FingerNum = fingerNum;
+	strncpy(finger.m_aLabel, m_EnrollLabel.c_str(), sizeof(finger.m_aLabel));
+	memcpy(finger.m_aDigest, digest, SHA256_SIZE);
+
+	char aHexDigest[SHA256_SIZE*2+1];
+	bytes2hex(finger.m_aDigest, sizeof(finger.m_aDigest), aHexDigest, sizeof(aHexDigest));
+	debugf("OnFingerEnrolled: \"%s\"", aHexDigest);
+
+	Serial1.printf("(sz: %d) Finger hexdigest: ", sizeof(finger.m_aDigest));
+	for(uint8_t i = 0; i < sizeof(finger.m_aDigest); i++)
+		Serial1.printf("%x", finger.m_aDigest[i]);
+	Serial1.printf("\n");
+
+	Settings().m_FingerPrints[fingerNum] = finger;
+	Settings().Save();
+	m_Enrolled = true;
+	m_Enrolling = false;
+	m_EnrolledFinger = finger;
+
+	char aBuf[512];
+	m_snprintf(aBuf, sizeof(aBuf), "Successfully enrolled new finger \"%s\".", finger.m_aLabel);
+	EnrollMessage(aBuf);
+
+	debugf("OnFingerEnrolled: OK!!!");
+}
diff --git a/app/main.h b/app/main.h
new file mode 100644
index 0000000..3e6143a
--- /dev/null
+++ b/app/main.h
@@ -0,0 +1,65 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#define FINGER_DETECT_PIN 4
+#define FINGER_ENABLE_PIN 5
+
+#define SAFELOCK_DATA_PIN 12
+#define SAFELOCK_DETECT_PIN 14
+
+#define DOOR_DETECT_PIN 13
+
+#include <ArduinoJson.h>
+#include "Settings.h"
+#include "FingerPrint.h"
+#include "FingerLogic.h"
+
+class CMain
+{
+public:
+	CMain();
+	void Init(HardwareSerial &serial);
+
+	void OnFingerInterrupt(bool finger);
+
+	void FingerEnable(bool enable);
+
+	void LockUnlock();
+	void EnrollMessage(const char *msg, bool error=false);
+
+	void OnFingerVerified(uint16_t fingerNum, uint8_t digest[SHA256_SIZE]);
+	void OnFingerEnrolled(uint16_t fingerNum, uint8_t digest[SHA256_SIZE]);
+
+	CSettings &Settings() { return m_Settings; }
+	CFingerPrint &FingerPrint() { return m_FingerPrint; }
+	CFingerLogic &FingerLogic() { return m_FingerLogic; }
+
+private:
+	bool HttpAuthorized(HttpRequest &request, HttpResponse &response);
+	void HttpOnApi(HttpRequest &request, HttpResponse &response);
+	void HttpOnFile(HttpRequest &request, HttpResponse &response);
+
+	HttpStatus HandleApi(HttpMethod method, String endpoint, JsonDocument &req, JsonDocument &resp);
+
+private:
+	void LockSendBytes(uint8_t *pBytes, uint8_t len);
+	void LockSendCode(uint8_t code[8]);
+
+	CSettings m_Settings;
+	CFingerPrint m_FingerPrint;
+	CFingerLogic m_FingerLogic;
+
+	FtpServer m_FTP;
+	HttpServer m_HttpServer;
+
+	String m_EnrollMessage;
+	String m_EnrollLabel;
+	CSettings::CFingerPrint m_EnrolledFinger;
+	bool m_Enrolling;
+	bool m_Enrolled;
+};
+
+extern CMain g_Main;
+extern HardwareSerial Serial1;
+
+#endif
diff --git a/app/utils.cpp b/app/utils.cpp
new file mode 100644
index 0000000..d082b36
--- /dev/null
+++ b/app/utils.cpp
@@ -0,0 +1,75 @@
+#include <SmingCore.h>
+#include "utils.h"
+
+static inline uint8_t _char2byte(char c)
+{
+	if('0' <= c && c <= '9') return (uint8_t)(c - '0');
+	if('A' <= c && c <= 'F') return (uint8_t)(c - 'A' + 10);
+	if('a' <= c && c <= 'f') return (uint8_t)(c - 'a' + 10);
+	return 0xFF;
+}
+
+int hex2bytes(const char *str, uint8_t *bytes, int32_t length)
+{
+	int result;
+	if(!str || !bytes || length <= 0)
+		return -1;
+
+	for(result = 0; *str; result++)
+	{
+		uint8_t msn = _char2byte(*str++);
+		if(msn == 0xFF) return -1;
+
+		uint8_t lsn = _char2byte(*str++);
+		if(lsn == 0xFF) return -1;
+
+		uint8_t bin = (msn << 4) + lsn;
+
+		if(length-- <= 0)
+			return -1;
+
+		*bytes++ = bin;
+	}
+
+	return result;
+}
+
+void bytes2hex(const uint8_t *bytes, int32_t length, char *str, int32_t strLength)
+{
+	const char binHex[] = "0123456789ABCDEF";
+
+	if(!str || strLength < 3)
+		return;
+	*str = 0;
+
+	if(!bytes || length <= 0 || strLength <= 2 * length)
+	{
+		strncpy(str, "ERR", strLength);
+		return;
+	}
+
+	for(; length > 0; length--, strLength -= 2)
+	{
+		uint8_t byte = *bytes++;
+
+		*str++ = binHex[(byte >> 4) & 0x0F];
+		*str++ = binHex[byte & 0x0F];
+	}
+
+	if(strLength-- <= 0)
+		return;
+
+	*str++ = 0;
+}
+
+int Rssi2Quality(sint8 rssi)
+{
+	if(rssi >= -100 && rssi <= -80)
+		return 1;
+	else if(rssi > -80 && rssi <= -65)
+		return 2;
+	else if(rssi > -65 && rssi < -50)
+		return 3;
+	else
+		return 4;
+}
diff --git a/app/utils.h b/app/utils.h
new file mode 100644
index 0000000..d0ed894
--- /dev/null
+++ b/app/utils.h
@@ -0,0 +1,8 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+int hex2bytes(const char *str, uint8_t *bytes, int32_t length);
+void bytes2hex(const uint8_t *bytes, int32_t length, char *str, int32_t strLength);
+int Rssi2Quality(sint8 rssi);
+
+#endif
diff --git a/component.mk b/component.mk
new file mode 100644
index 0000000..dcb4953
--- /dev/null
+++ b/component.mk
@@ -0,0 +1,4 @@
+ARDUINO_LIBRARIES := ArduinoJson6
+
+HWCONFIG = spiffs
+SPIFF_FILES = files
diff --git a/files/.gitkeep b/files/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/files/bootstrap.min.css.gz b/files/bootstrap.min.css.gz
new file mode 100644
index 0000000000000000000000000000000000000000..71634cbfdeba63409e3c25fa5ca092c3541fafb3
GIT binary patch
literal 18466
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
AVgLXD

literal 0
HcmV?d00001

diff --git a/files/bootstrap.min.js.gz b/files/bootstrap.min.js.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d01045cd4a34e3c51baf435ee0851cf4959ae687
GIT binary patch
literal 12913
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
DWey7_

literal 0
HcmV?d00001

diff --git a/files/favicon.ico b/files/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..23ceec5c4cd0158aafbd691c5c778a7da013ab6a
GIT binary patch
literal 1150
zcmZQzU}Ruq5D);-3Je)63=Con3=A3!3=9Gc3=9ek5OD?&U;z=R_~FBcvR$1W<!!Ak
zHKgF4?yl13&!0;a7UWIhU}ybL4sK|uYs}Bfos6zmP=N2VxR}U0WGpNs@EKiQO-*$h
zHvMH~rG5YZ|7SqP^XAUUB38e?p3d!GzkabI>yM6#Tt}>aP7b!e7cN{dg6aSM{X3Ve
zjMOV)^@G$kH8!-t^q)L=(u#wf^)E;q8RPOlHy6jR1@q^n!}K3Ne$1YqkLMe*UJx6X
z{+#TrIWWC2x~r?R4x|Se<I=x%>((HcJ{W!J;zeU*y&yI&{TtS=3y0~0(Pz(|wE*cs
z#<=uHM1-yX`}Z#+OfQHoEh(OYtQW+_rJs|7?N45A&di%PZ))GYdsnTgv7rMLrXW4Y
z7?*yS8c;d_VQg^+QUlUoR9G+p#3l#V)z!A#zI|Jzs<N`ZqN2Qu6b!Qa?%lhJ|NkS(
h1Lg+|49o{0m=Q{Y#MmD&Fn};fj<EruzJZZ}0RZTDs@(tp

literal 0
HcmV?d00001

diff --git a/files/index.html b/files/index.html
new file mode 100644
index 0000000..1c18dbe
--- /dev/null
+++ b/files/index.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+	<meta name="description" content="Safe control panel">
+	<title>Safe control panel</title>
+
+	<link rel="icon" type="image/x-icon" href="favicon.ico">
+	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha256-LA89z+k9fjgMKQ/kq4OO2Mrf8VltYml/VES+Rg0fh20=" crossorigin="anonymous" />
+	<link rel="stylesheet" href="main.css">
+</head>
+
+<body>
+<div class="spinner"><div class="rect1"></div> <div class="rect2"></div> <div class="rect3"></div> <div class="rect4"></div> <div class="rect5"></div></div>
+<noscript><center><h1>Your browser does not support JavaScript!</h1></center></noscript>
+</body>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js" integrity="sha256-FgpCb/KJQlLNfOu91ta32o/NMZxltwRo8QtmkMRdAu8=" crossorigin="anonymous"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/nunjucks/3.0.1/nunjucks.min.js" integrity="sha256-sh9FYQZVVLprCQB3/IcNyCRrZwu9hZ+xLHhUszDfsK4=" crossorigin="anonymous"></script>
+<script src="templates.js"></script>
+<script src="main.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js" integrity="sha256-pS96pU17yq+gVu4KBQJi38VpSuKN7otMrDQprzf/DWY=" crossorigin="anonymous"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha256-5+02zu5UULQkO7w1GIr6vftCgMfFdZcAHeDtFnKZsBs=" crossorigin="anonymous"></script>
+</html>
diff --git a/files/jquery-3.2.1.min.js.gz b/files/jquery-3.2.1.min.js.gz
new file mode 100644
index 0000000000000000000000000000000000000000..269d2de4f5eef069a9295ae87775c8c6548cacdb
GIT binary patch
literal 29995
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
AX8-^I

literal 0
HcmV?d00001

diff --git a/files/main.css.gz b/files/main.css.gz
new file mode 100644
index 0000000000000000000000000000000000000000..772ab62f41e4f23ee429ec74b99f68e1037d9858
GIT binary patch
literal 653
zcmb2|=HNIGcrlWRIX5vgPcON+m|<?{ZNJ9`0=0hol2lrbEGqTTSKzpmRi9v=AV0Ta
zQdH^N6Z0-Hz1siYB6C_^CRdKUR<%v>xsNe(W@rC+I!|EA?T8g~RJX9Gh84*Qm~n8Q
zY!}Mf>&hBtH}w*;u1X`H!Rb8Pbqz}l3u-4%^RqpiJ!?ylX0Ej3I^Az}{V(-=^VcOV
z&gOMA50mQfkeTW#?LKu=l-a$tYqb*Io((nWzEI^WvFV!G{R37HH@bTEXD%wq=&jLn
zh+eGQb!kVIWTcgaVSBxR>+2@9w>gZKPh|F8>=I+WbN06Gd$AR>Sw#)rZ(}}|BjS8y
zhyP=r<ArLMf9o^&o@21}v1cvW#d7hEMEEAvEw`fHa9^Ii!_p?*s%Upu*er{e6JPYk
zPCGc$R8gAu+L>wPcVd73e%gH@?BTWs_J6V`W<B}&boR5qdP3KZ<#I)2EWJ?1DN(Xl
zPN>|slH)wb&nF*l+5YwV<>tOHyQsc(@5-m4FFWq6ivMkArpLKmWy!-7(SVN$3(}L%
zIx98R9Xzpp{dtA=>>7VdLYAG9e9paN#@V#R;rm~g^qG{->foK`eKu%K+{u6M5;d7B
zmt-w8n3g`tm-+bBTb~XvoNAaO^6*+=#6SHv529us@7iTox7?+~Vk7HjPm3p3Ru*ov
zYg?xEFMO(g;o0+xpWZw)iK;K?Df=yW>#xME+V*e79kGv!-#+C!ynBzaW8KfW(o_B?
zX&=z$aeT6rckAaneG4bC)yF@*`A7QArIcTd^3T<NZERRCu-vm~)};3{=7=Aav!2n{
z<YN2W@tfT4f0<SP*_MjmnaNxAk0*kwDJ4_D!|}CY5nuD%<7@hNY?8LuSTeIf;;HC<
SZMNhy^7?ryxBjs)FaQ9=Njz8p

literal 0
HcmV?d00001

diff --git a/files/main.js.gz b/files/main.js.gz
new file mode 100644
index 0000000000000000000000000000000000000000..8044855d87afbd51795f2f4135fab2da56a2cddc
GIT binary patch
literal 742
zcmb2|=HNJe*)WQUIX5vgPcN&OVQr{)zLcSW-Qo2HBB{MDy_2?0_dT(8<rU{(&b(0m
zW7!8*ZVcZxokjJ}_a6D(Iw~eBubf_2mbPzZ{=D1kb=<E>9*p_F>Gs`#=7?0D@VsN!
zmoDjxXItnUZ$352FC+CLi*1=T>(<pfmn}PSQ7KbEuF5yvVcMPA`S<=ExH)55(w!M;
zi;szkU%8lZFL3Iv)i>n56)Fz$o|9sT+_{xyig{k*PDACC9lk%#F^JC!&0gU5Y}XAw
zW}fP1@Adav!z<po-96{DLe+e!;HkZ5_on`d`=)#1|MUBI9oI`;3cAd+$k%(Jh&e~G
z>+?y@&2v^(e0XP_F}bRV&EoflDOG+?kE@*76TUHHL3;X%=^-vfTT51lOi%7w`cPG+
z$M)cxRRYpSRJN8~>i_q(P1<w&-`A@RU#z>$cCuE!bJ4bSH^1=n@TR}p^R1!JR9xM3
zzF(Hz{3|t?GuqPGGFz*Z^%8w+8ml%sZImhP<cW7)W?{n7<;^$gd|R&VmUk<Pzs^&P
zc^`4vXv61No4CF4Tc4D_isI){Rz4h?DiRg&Kzb3Yebl?fK5_5LpL<;D;yiWuC6}ke
zjt_npZ@sHt|D(N!{YTsir~CYzJayZe&ZcQ|abLQ(Of7f&bHPBDEVsS9A3c&*@7y1e
z)p`E)&eG+Nk008iy;r{^hhtB}gNwWp0#)wv%O)gt$_p;eIr=#wT!bMZAWOQB<-?t3
zZROX#+eMS_-1@boqTXW7uG`Zd==`p<o|~$y&k)dObE&@KgHF_)$hDi?W+=<|9=UTg
zN&3BifbrTn=PeIqM0yEoo88;(QSxb4c(HGi*~>?JeV(l~*;iXzE>^$vLG<~nY#b)X
zMJ`2kq^4TjdAKW6EbUnP{^y@%Y?ZRMcRhW0MN#7W4e0{sjKDh_FCXdFJz(E28@kqg
zMeU7CD$R2&Y9F613|YKfy+lxhFS~E;$2<QQZ!+mv&zr;Zu|Ih4>v?k`{hvxINK9_r
I!Op+{02@qdNdN!<

literal 0
HcmV?d00001

diff --git a/files/nunjucks.min.js.gz b/files/nunjucks.min.js.gz
new file mode 100644
index 0000000000000000000000000000000000000000..ff6749fbe9f1f06e4ec5b8624ef14ff949665c21
GIT binary patch
literal 22603
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

literal 0
HcmV?d00001

diff --git a/files/popper.min.js.gz b/files/popper.min.js.gz
new file mode 100644
index 0000000000000000000000000000000000000000..78a60d71dd6b6d9fab2fcd4c10a2bc73966b22ce
GIT binary patch
literal 6963
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
RWW@bpPptd3LdBbb0RY`8dV&A|

literal 0
HcmV?d00001

diff --git a/files/settings.conf b/files/settings.conf
new file mode 100644
index 0000000..99c40d7
--- /dev/null
+++ b/files/settings.conf
@@ -0,0 +1,25 @@
+{
+  "username": "admin",
+  "password": "password",
+  "network": {
+    "ssid": "",
+    "passphrase": "",
+    "dhcp": true,
+    "hostname": "safeweb",
+    "address": "0.0.0.0",
+    "netmask": "0.0.0.0",
+    "gateway": "0.0.0.0"
+  },
+  "lock_code": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7
+  ],
+  "fingerprints": [
+  ]
+}
\ No newline at end of file
diff --git a/files/templates.js.gz b/files/templates.js.gz
new file mode 100644
index 0000000000000000000000000000000000000000..ff7a6ba78b3d1a23c1ff88e12b6c6580a73216ae
GIT binary patch
literal 4065
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
YxoT_Qy_Y^`V*Zc4(D03BOcVnH0D}YA8~^|S

literal 0
HcmV?d00001

diff --git a/files/wifi-sprites.png b/files/wifi-sprites.png
new file mode 100644
index 0000000000000000000000000000000000000000..863d0d7f28d60e96bcc36f55a461e79816598c21
GIT binary patch
literal 1815
zcmeAS@N?(olHy`uVBq!ia0y~yU}RumV9?=UV_;zD%1)clz`($k<n8Xl@E-&h>|H*Y
zfq{Xuz$3Dlfq`2Xgc%uT&5>YWU|=ut^mS!_$id5RV7={lW+4LugKTC<M2T~LZf<H`
z3CLIm=c3falGGH1^30M91$R&1fE2w{b_NEvYEKu(kcwMx=f-!)UX?v=zu(yS`@4I0
zbChPW{T5iwsC(p9a<=rE6)r1717}}Z^`Kc_)aA&&9|~WV`sZfmY6gjDUb+<GrOVaz
z{{Z_zdl%`&y#E+G7rF6v-i*Duw>tgVoOt;%;l1C_ow>W_?4&t=Ywwl)do%O>9OL_z
z-~ZGV_X#NT$1Ylu8?g4?`bOTjn#=O5LXxKJ|GIJh>+RR(p7gmXduzI<)53WR8pYTD
zD4p_acm2O@rz~#^uAH`fRZF@2^5Wya17F$K++)49tEl>IU8rjP8_sh-9^`s1Hfgw~
z^7fjFqw~{uN)<7yo!87U+t;YB_ct~9@x5<nY^7G$-7HZ|zWx8kiu#8SyG8Ex2i1R?
z`#JJ^`+c)l|Nrb3*OuSoJBMvS<2?O_fb_;64;Gs?_y}DyvAT78%even2@Shy^2;SI
z2CmpXJ7ET+L|Y<Tf<&8SL!v|)LtCQE<0t)0fBx=z%A0xb%X^LFU4Pyl?>a5TZ&{tB
z{Cj<^g4f@@>F<M1$z3_}C9pMT&bO!gyMz9}nY%xrYtKgsN$K>v@585EF8n0jp#NIC
zUiZRm$Ee_prziF~d^oc!Y|E#w58{sH)$QBJSR%hq<JKIu{ptG4_kM^e_W56JAG7h_
z<a-QJo?a6~B(A-1IpMru@{%*hZ!vB1JhtiNsSERj-Q~EJ9lKs^am()2ix%CJ#~#-*
zmP}i?fAgm$+a}**=n7cmr^Wl=#WJNSAI%tepS=1QYRkae{ae{DE2u}flb1;f?njuX
z-JYz;5=lt9&i8i9@sEiWIp%_i>)vcE{hL-6|8sW6<f?OTa+X|pxWZM7v%PxrogJ0Z
z^?wiE4SY5K|K&8-Nx#mQx=z^0+jD=L`ngW4Z8@PokGZV~THc^#Wq$r;{<~=!yb0^f
z&(5h@;hlByfVHvw(d_L%ZQ3vEpQsH~ysv2Y{O(QWi>Iy!DEZc&W4JZDGpxSsYyXU0
z>wiA|_Vc@b<kb_;S4lN^IK2w$>e?wGBr|W)#w|y4w%G3o5)zsaaFMx)rEtsSip{?`
z80VOoPDu5AmN;h-+X4+mmQ|OmZMtuJ^9tV2JF5TfYune?i~c!m2+Le^&-!FuV<OD!
z@US>?_S9mA`kg+rn|FD62Yrg3-(|e=`N3ST?4*yA?<lf3om_U(w`N;$_>^DI-`%z-
zTBhWb@MxXCa%}B$r`)$Y=IuIv#dX2<*YoH6yJy#Vi6QE(rbkqU>m4&juh3h1iv3ru
zZU>j#dabEFX_in+p2mwFU)MkHJOs?M7$;Sv7kQntoL#y<E3WqCiEXE+eE)XzCbNc9
zXOL~+@ryRwTLlVzqM7#wg!o@+Y^d_e=Po%C{r_}C?F$i)tWAatha(Py`~pk1AofNx
z55{w~f6DIKmrpR9u3NkI+IxYeS~D&7{dj4=sONRf=lJcf7AEzXaW)5+swnBSH0cV@
zu6RD{_u?z}_ttl>dT%PXSZc<O&kj?5@y{)t7t}W+%8upSkCgo`nGEww`U6@vCB{}J
zE_~zqy6N&!n@Ww7ny;hm<<H4?h3%ilt+38AM_%cl-+qk)I|bP!mj4q`DCF$k`hG=R
zm*at@7q8VfMPG`adR@UmL3ZlbvQ@^f?ryuL{;J~&L+t+Drky?JE8R0Mt@r+#FI*}y
zQ3{$B!G2oC<M8B&i}@tc8s29qAH;uj?%XE4wDRcn&!#1O^JaP`>E4bI)0B~A5qZ_#
z)L;Hvso9dXNyqoEj_H5zHnwQi*omAfk3R4!Uq75En^|)xWXrc%tL4&ScYRuD8&p4^
z)!gPr-J2i3iVitgetmf7fB(ZZs|@uHuPEJMt9$y+{&{t!MR%_2<*~}<mH)ZE^7zLh
zZ$=}QkCqnZS2Frdr(D>t?yBLu@5?kfJNM9&m&{z_U8nw-a9xMzk;0TMY+7or8cz8u
zH-=AXo}~Ks=>oa;)gi8WER6yuHht9JzOsG7^(hY>Y}al%8xt?Nc#B90oAdI84z+xV
z6^Rp$s7~4Ep8Y|(`u#`G&$ik8Q;IiKx1658J6!xwL7emP)Ge+SAtn2#2>p3<M9p{M
zzJs5xE`GYgJ?BH*w6o7U3~p3%vfod5cyYeTu?Jrcy!%&dSJ(MYIXv_7VtKpjzuKXZ
zO6L~(F0{K}|L|Y$f1}#BepA~{M1Fi#|Lfnm`8Bg<&fRX3r5S(w^7_>K(P!>_FwQ;Y
vtP%h6di=gUvtO=Wx8Byh;nUZ>41f5Kh&OOmXHNbKs-Qew{an^LB{Ts5UFCSb

literal 0
HcmV?d00001

diff --git a/out/.gitignore b/out/.gitignore
new file mode 100644
index 0000000..d6b7ef3
--- /dev/null
+++ b/out/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore