外观
软件开发
开发环境
- 软件环境：VSCode+PlatformIO
- 开发语言：C/C++
依赖库
通过以下开源库协助本项目开发 - EspSoftwareSerial：软串口驱动库
- Adafruit SSD1306：屏幕驱动库
蓝牙
蓝牙HID驱动
蓝牙HID基于BleKeyboard库修改，原库年久失修，由于安全协议问题会导致最新Windows及Android系统拒绝与其通讯
#include "BleKeyboard.h"
#if defined(USE_NIMBLE)
#include <NimBLEDevice.h>
#include <NimBLEServer.h>
#include <NimBLEUtils.h>
#include <NimBLEHIDDevice.h>
#else
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include "BLE2902.h"
#include "BLEHIDDevice.h"
#endif // USE_NIMBLE
#include "HIDTypes.h"
#include <driver/adc.h>
#include "sdkconfig.h"
#if defined(CONFIG_ARDUHAL_ESP_LOG)
#include "esp32-hal-log.h"
#define LOG_TAG ""
#else
#include "esp_log.h"
static const char* LOG_TAG = "BLEDevice";
#endif
// Report IDs:
#define KEYBOARD_ID 0x01
#define MEDIA_KEYS_ID 0x02
static const uint8_t _hidReportDescriptor[] = {
USAGE_PAGE(1), 0x01, // USAGE_PAGE (Generic Desktop Ctrls)
USAGE(1), 0x06, // USAGE (Keyboard)
COLLECTION(1), 0x01, // COLLECTION (Application)
// ------------------------------------------------- Keyboard
REPORT_ID(1), KEYBOARD_ID, // REPORT_ID (1)
USAGE_PAGE(1), 0x07, // USAGE_PAGE (Kbrd/Keypad)
USAGE_MINIMUM(1), 0xE0, // USAGE_MINIMUM (0xE0)
USAGE_MAXIMUM(1), 0xE7, // USAGE_MAXIMUM (0xE7)
LOGICAL_MINIMUM(1), 0x00, // LOGICAL_MINIMUM (0)
LOGICAL_MAXIMUM(1), 0x01, // Logical Maximum (1)
REPORT_SIZE(1), 0x01, // REPORT_SIZE (1)
REPORT_COUNT(1), 0x08, // REPORT_COUNT (8)
HIDINPUT(1), 0x02, // INPUT (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
REPORT_COUNT(1), 0x01, // REPORT_COUNT (1) ; 1 byte (Reserved)
REPORT_SIZE(1), 0x08, // REPORT_SIZE (8)
HIDINPUT(1), 0x01, // INPUT (Const,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
REPORT_COUNT(1), 0x05, // REPORT_COUNT (5) ; 5 bits (Num lock, Caps lock, Scroll lock, Compose, Kana)
REPORT_SIZE(1), 0x01, // REPORT_SIZE (1)
USAGE_PAGE(1), 0x08, // USAGE_PAGE (LEDs)
USAGE_MINIMUM(1), 0x01, // USAGE_MINIMUM (0x01) ; Num Lock
USAGE_MAXIMUM(1), 0x05, // USAGE_MAXIMUM (0x05) ; Kana
HIDOUTPUT(1), 0x02, // OUTPUT (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
REPORT_COUNT(1), 0x01, // REPORT_COUNT (1) ; 3 bits (Padding)
REPORT_SIZE(1), 0x03, // REPORT_SIZE (3)
HIDOUTPUT(1), 0x01, // OUTPUT (Const,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
REPORT_COUNT(1), 0x06, // REPORT_COUNT (6) ; 6 bytes (Keys)
REPORT_SIZE(1), 0x08, // REPORT_SIZE(8)
LOGICAL_MINIMUM(1), 0x00, // LOGICAL_MINIMUM(0)
LOGICAL_MAXIMUM(1), 0x65, // LOGICAL_MAXIMUM(0x65) ; 101 keys
USAGE_PAGE(1), 0x07, // USAGE_PAGE (Kbrd/Keypad)
USAGE_MINIMUM(1), 0x00, // USAGE_MINIMUM (0)
USAGE_MAXIMUM(1), 0x65, // USAGE_MAXIMUM (0x65)
HIDINPUT(1), 0x00, // INPUT (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
END_COLLECTION(0), // END_COLLECTION
// ------------------------------------------------- Media Keys
USAGE_PAGE(1), 0x0C, // USAGE_PAGE (Consumer)
USAGE(1), 0x01, // USAGE (Consumer Control)
COLLECTION(1), 0x01, // COLLECTION (Application)
REPORT_ID(1), MEDIA_KEYS_ID, // REPORT_ID (3)
USAGE_PAGE(1), 0x0C, // USAGE_PAGE (Consumer)
LOGICAL_MINIMUM(1), 0x00, // LOGICAL_MINIMUM (0)
LOGICAL_MAXIMUM(1), 0x01, // LOGICAL_MAXIMUM (1)
REPORT_SIZE(1), 0x01, // REPORT_SIZE (1)
REPORT_COUNT(1), 0x10, // REPORT_COUNT (16)
USAGE(1), 0xB5, // USAGE (Scan Next Track) ; bit 0: 1
USAGE(1), 0xB6, // USAGE (Scan Previous Track) ; bit 1: 2
USAGE(1), 0xB7, // USAGE (Stop) ; bit 2: 4
USAGE(1), 0xCD, // USAGE (Play/Pause) ; bit 3: 8
USAGE(1), 0xE2, // USAGE (Mute) ; bit 4: 16
USAGE(1), 0xE9, // USAGE (Volume Increment) ; bit 5: 32
USAGE(1), 0xEA, // USAGE (Volume Decrement) ; bit 6: 64
USAGE(2), 0x23, 0x02, // Usage (WWW Home) ; bit 7: 128
USAGE(2), 0x94, 0x01, // Usage (My Computer) ; bit 0: 1
USAGE(2), 0x92, 0x01, // Usage (Calculator) ; bit 1: 2
USAGE(2), 0x2A, 0x02, // Usage (WWW fav) ; bit 2: 4
USAGE(2), 0x21, 0x02, // Usage (WWW search) ; bit 3: 8
USAGE(2), 0x26, 0x02, // Usage (WWW stop) ; bit 4: 16
USAGE(2), 0x24, 0x02, // Usage (WWW back) ; bit 5: 32
USAGE(2), 0x83, 0x01, // Usage (Media sel) ; bit 6: 64
USAGE(2), 0x8A, 0x01, // Usage (Mail) ; bit 7: 128
HIDINPUT(1), 0x02, // INPUT (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
END_COLLECTION(0) // END_COLLECTION
};
BleKeyboard::BleKeyboard(std::string deviceName, std::string deviceManufacturer, uint8_t batteryLevel)
: hid(0)
, deviceName(std::string(deviceName).substr(0, 15))
, deviceManufacturer(std::string(deviceManufacturer).substr(0,15))
, batteryLevel(batteryLevel) {}
void BleKeyboard::begin(void)
{
BLEDevice::init(deviceName);
BLEServer* pServer = BLEDevice::createServer();
pServer->setCallbacks(this);
_mediaKeyReport[0] = 0;
_mediaKeyReport[1] = 0;
memset(&_keyReport, 0, sizeof(_keyReport));
hid = new BLEHIDDevice(pServer);
inputKeyboard = hid->inputReport(KEYBOARD_ID); // <-- input REPORTID from report map
outputKeyboard = hid->outputReport(KEYBOARD_ID);
inputMediaKeys = hid->inputReport(MEDIA_KEYS_ID);
outputKeyboard->setCallbacks(this);
hid->manufacturer()->setValue(deviceManufacturer);
hid->pnp(0x02, vid, pid, version);
hid->hidInfo(0x00, 0x01);
#if defined(USE_NIMBLE)
BLEDevice::setSecurityAuth(true, true, true);
#else
BLESecurity* pSecurity = new BLESecurity();
pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_MITM_BOND);
pSecurity->setCapability(ESP_IO_CAP_NONE);//安全设置
pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
#endif // USE_NIMBLE
hid->reportMap((uint8_t*)_hidReportDescriptor, sizeof(_hidReportDescriptor));
hid->startServices();
onStarted(pServer);
advertising = pServer->getAdvertising();
advertising->setAppearance(HID_KEYBOARD);
advertising->addServiceUUID(hid->hidService()->getUUID());
advertising->setScanResponse(false);
advertising->start();
hid->setBatteryLevel(batteryLevel);
ESP_LOGD(LOG_TAG, "Advertising started!");
}
void BleKeyboard::end(void)
{
}
bool BleKeyboard::isConnected(void) {
return this->connected;
}
void BleKeyboard::setBatteryLevel(uint8_t level) {
this->batteryLevel = level;
if (hid != 0)
this->hid->setBatteryLevel(this->batteryLevel);
}
//must be called before begin in order to set the name
void BleKeyboard::setName(std::string deviceName) {
this->deviceName = deviceName;
}
/**
* @brief Sets the waiting time (in milliseconds) between multiple keystrokes in NimBLE mode.
*
* @param ms Time in milliseconds
*/
void BleKeyboard::setDelay(uint32_t ms) {
this->_delay_ms = ms;
}
void BleKeyboard::set_vendor_id(uint16_t vid) {
this->vid = vid;
}
void BleKeyboard::set_product_id(uint16_t pid) {
this->pid = pid;
}
void BleKeyboard::set_version(uint16_t version) {
this->version = version;
}
void BleKeyboard::sendReport(KeyReport* keys)
{
if (this->isConnected())
{
this->inputKeyboard->setValue((uint8_t*)keys, sizeof(KeyReport));
this->inputKeyboard->notify();
#if defined(USE_NIMBLE)
// vTaskDelay(delayTicks);
this->delay_ms(_delay_ms);
#endif // USE_NIMBLE
}
}
void BleKeyboard::sendReport(MediaKeyReport* keys)
{
if (this->isConnected())
{
this->inputMediaKeys->setValue((uint8_t*)keys, sizeof(MediaKeyReport));
this->inputMediaKeys->notify();
#if defined(USE_NIMBLE)
//vTaskDelay(delayTicks);
this->delay_ms(_delay_ms);
#endif // USE_NIMBLE
}
}
extern
const uint8_t _asciimap[128] PROGMEM;
#define SHIFT 0x80
const uint8_t _asciimap[128] =
{
0x00, // NUL
0x00, // SOH
0x00, // STX
0x00, // ETX
0x00, // EOT
0x00, // ENQ
0x00, // ACK
0x00, // BEL
0x2a, // BS Backspace
0x2b, // TAB Tab
0x28, // LF Enter
0x00, // VT
0x00, // FF
0x00, // CR
0x00, // SO
0x00, // SI
0x00, // DEL
0x00, // DC1
0x00, // DC2
0x00, // DC3
0x00, // DC4
0x00, // NAK
0x00, // SYN
0x00, // ETB
0x00, // CAN
0x00, // EM
0x00, // SUB
0x00, // ESC
0x00, // FS
0x00, // GS
0x00, // RS
0x00, // US
0x2c, // ' '
0x1e|SHIFT, // !
0x34|SHIFT, // "
0x20|SHIFT, // #
0x21|SHIFT, // $
0x22|SHIFT, // %
0x24|SHIFT, // &
0x34, // '
0x26|SHIFT, // (
0x27|SHIFT, // )
0x25|SHIFT, // *
0x2e|SHIFT, // +
0x36, // ,
0x2d, // -
0x37, // .
0x38, // /
0x27, // 0
0x1e, // 1
0x1f, // 2
0x20, // 3
0x21, // 4
0x22, // 5
0x23, // 6
0x24, // 7
0x25, // 8
0x26, // 9
0x33|SHIFT, // :
0x33, // ;
0x36|SHIFT, // <
0x2e, // =
0x37|SHIFT, // >
0x38|SHIFT, // ?
0x1f|SHIFT, // @
0x04|SHIFT, // A
0x05|SHIFT, // B
0x06|SHIFT, // C
0x07|SHIFT, // D
0x08|SHIFT, // E
0x09|SHIFT, // F
0x0a|SHIFT, // G
0x0b|SHIFT, // H
0x0c|SHIFT, // I
0x0d|SHIFT, // J
0x0e|SHIFT, // K
0x0f|SHIFT, // L
0x10|SHIFT, // M
0x11|SHIFT, // N
0x12|SHIFT, // O
0x13|SHIFT, // P
0x14|SHIFT, // Q
0x15|SHIFT, // R
0x16|SHIFT, // S
0x17|SHIFT, // T
0x18|SHIFT, // U
0x19|SHIFT, // V
0x1a|SHIFT, // W
0x1b|SHIFT, // X
0x1c|SHIFT, // Y
0x1d|SHIFT, // Z
0x2f, // [
0x31, // bslash
0x30, // ]
0x23|SHIFT, // ^
0x2d|SHIFT, // _
0x35, // `
0x04, // a
0x05, // b
0x06, // c
0x07, // d
0x08, // e
0x09, // f
0x0a, // g
0x0b, // h
0x0c, // i
0x0d, // j
0x0e, // k
0x0f, // l
0x10, // m
0x11, // n
0x12, // o
0x13, // p
0x14, // q
0x15, // r
0x16, // s
0x17, // t
0x18, // u
0x19, // v
0x1a, // w
0x1b, // x
0x1c, // y
0x1d, // z
0x2f|SHIFT, // {
0x31|SHIFT, // |
0x30|SHIFT, // }
0x35|SHIFT, // ~
0 // DEL
};
uint8_t USBPutChar(uint8_t c);
// press() adds the specified key (printing, non-printing, or modifier)
// to the persistent key report and sends the report. Because of the way
// USB HID works, the host acts like the key remains pressed until we
// call release(), releaseAll(), or otherwise clear the report and resend.
size_t BleKeyboard::press(uint8_t k)
{
uint8_t i;
if (k >= 136) { // it's a non-printing key (not a modifier)
k = k - 136;
} else if (k >= 128) { // it's a modifier key
_keyReport.modifiers |= (1<<(k-128));
k = 0;
} else { // it's a printing key
k = pgm_read_byte(_asciimap + k);
if (!k) {
setWriteError();
return 0;
}
if (k & 0x80) { // it's a capital letter or other character reached with shift
_keyReport.modifiers |= 0x02; // the left shift modifier
k &= 0x7F;
}
}
// Add k to the key report only if it's not already present
// and if there is an empty slot.
if (_keyReport.keys[0] != k && _keyReport.keys[1] != k &&
_keyReport.keys[2] != k && _keyReport.keys[3] != k &&
_keyReport.keys[4] != k && _keyReport.keys[5] != k) {
for (i=0; i<6; i++) {
if (_keyReport.keys[i] == 0x00) {
_keyReport.keys[i] = k;
break;
}
}
if (i == 6) {
setWriteError();
return 0;
}
}
sendReport(&_keyReport);
return 1;
}
size_t BleKeyboard::press(const MediaKeyReport k)
{
uint16_t k_16 = k[1] | (k[0] << 8);
uint16_t mediaKeyReport_16 = _mediaKeyReport[1] | (_mediaKeyReport[0] << 8);
mediaKeyReport_16 |= k_16;
_mediaKeyReport[0] = (uint8_t)((mediaKeyReport_16 & 0xFF00) >> 8);
_mediaKeyReport[1] = (uint8_t)(mediaKeyReport_16 & 0x00FF);
sendReport(&_mediaKeyReport);
return 1;
}
// release() takes the specified key out of the persistent key report and
// sends the report. This tells the OS the key is no longer pressed and that
// it shouldn't be repeated any more.
size_t BleKeyboard::release(uint8_t k)
{
uint8_t i;
if (k >= 136) { // it's a non-printing key (not a modifier)
k = k - 136;
} else if (k >= 128) { // it's a modifier key
_keyReport.modifiers &= ~(1<<(k-128));
k = 0;
} else { // it's a printing key
k = pgm_read_byte(_asciimap + k);
if (!k) {
return 0;
}
if (k & 0x80) { // it's a capital letter or other character reached with shift
_keyReport.modifiers &= ~(0x02); // the left shift modifier
k &= 0x7F;
}
}
// Test the key report to see if k is present. Clear it if it exists.
// Check all positions in case the key is present more than once (which it shouldn't be)
for (i=0; i<6; i++) {
if (0 != k && _keyReport.keys[i] == k) {
_keyReport.keys[i] = 0x00;
}
}
sendReport(&_keyReport);
return 1;
}
size_t BleKeyboard::release(const MediaKeyReport k)
{
uint16_t k_16 = k[1] | (k[0] << 8);
uint16_t mediaKeyReport_16 = _mediaKeyReport[1] | (_mediaKeyReport[0] << 8);
mediaKeyReport_16 &= ~k_16;
_mediaKeyReport[0] = (uint8_t)((mediaKeyReport_16 & 0xFF00) >> 8);
_mediaKeyReport[1] = (uint8_t)(mediaKeyReport_16 & 0x00FF);
sendReport(&_mediaKeyReport);
return 1;
}
void BleKeyboard::releaseAll(void)
{
_keyReport.keys[0] = 0;
_keyReport.keys[1] = 0;
_keyReport.keys[2] = 0;
_keyReport.keys[3] = 0;
_keyReport.keys[4] = 0;
_keyReport.keys[5] = 0;
_keyReport.modifiers = 0;
_mediaKeyReport[0] = 0;
_mediaKeyReport[1] = 0;
sendReport(&_keyReport);
}
size_t BleKeyboard::write(uint8_t c)
{
uint8_t p = press(c); // Keydown
release(c); // Keyup
return p; // just return the result of press() since release() almost always returns 1
}
size_t BleKeyboard::write(const MediaKeyReport c)
{
uint16_t p = press(c); // Keydown
release(c); // Keyup
return p; // just return the result of press() since release() almost always returns 1
}
size_t BleKeyboard::write(const uint8_t *buffer, size_t size) {
size_t n = 0;
while (size--) {
if (*buffer != '\r') {
if (write(*buffer)) {
n++;
} else {
break;
}
}
buffer++;
}
return n;
}
void BleKeyboard::onConnect(BLEServer* pServer) {
this->connected = true;
#if !defined(USE_NIMBLE)
BLE2902* desc = (BLE2902*)this->inputKeyboard->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
desc->setNotifications(true);
desc = (BLE2902*)this->inputMediaKeys->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
desc->setNotifications(true);
#endif // !USE_NIMBLE
}
void BleKeyboard::onDisconnect(BLEServer* pServer) {
this->connected = false;
#if !defined(USE_NIMBLE)
BLE2902* desc = (BLE2902*)this->inputKeyboard->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
desc->setNotifications(false);
desc = (BLE2902*)this->inputMediaKeys->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
desc->setNotifications(false);
advertising->start();
#endif // !USE_NIMBLE
}
void BleKeyboard::onWrite(BLECharacteristic* me) {
uint8_t* value = (uint8_t*)(me->getValue().c_str());
(void)value;
ESP_LOGI(LOG_TAG, "special keys: %d", *value);
}
void BleKeyboard::delay_ms(uint64_t ms) {
uint64_t m = esp_timer_get_time();
if(ms){
uint64_t e = (m + (ms * 1000));
if(m > e){ //overflow
while(esp_timer_get_time() > e) { }
}
while(esp_timer_get_time() < e) {}
}
}读取数据
readSensor()
用于读取LD2402数据及主逻辑实现。
通过对原库receiveResponse()函数改良，添加数据位判断，以及init初始化添加等待延时解决。
#include <fingerprint.h>
// 创建软串口对象
SoftwareSerial fingerprintSerial(FINGERPRINT_RX, FINGERPRINT_TX);
// 定义缓冲区ID
uint8_t BUFFER_ID = 0;
// 全局变量
bool isInit = false;
void printHex(uint8_t* data, uint8_t len) {
for(uint8_t i=0; i<len; i++){
if(data[i] < 0x10) Serial.print('0');
Serial.print(data[i], HEX);
Serial.print(' ');
}
Serial.println();
}
void initfingerprint() {
// 初始化串口
// Serial.begin(9600);
fingerprintSerial.begin(57600);
while (fingerprintSerial.available()) fingerprintSerial.read();
//while (Serial.available()) Serial.read();
// delay(1000); // 等待串口稳定
}
void command_use(void)
{
Serial.println("------------------------------------------");
Serial.println("command input:");
Serial.println("\"1\" means \"register fingerprint.\"");
Serial.println("\"2\" means \"search fingerprint.\"");
Serial.println("\"3\" means \"clear fingerprint.\"");
Serial.println("------------------------------------------");
}
bool run_command(void)
{
if (Serial.available() > 0) {
String command = Serial.readStringUntil('\n');
command.trim();
if (command.length() == 0) return false; // 忽略空命令
if (command == "1") {
Serial.println("[INFO] registering...");
if(register_FP()) {
Serial.println("FP registration process complete!");
} else {
Serial.println("FP registration process fail! Please 'register' again!!!");
}
}
else if (command == "2") {
Serial.println("[INFO] searching...");
if(search_FP()) {
Serial.println("FP match succ!");
} else {
Serial.println("FP match fail! Please 'search' again!!!");
}
}
else if (command == "3") {
Serial.println("[INFO] clearing...");
if(clear_FP_all_lib()) {
Serial.println("FP clear FP all lib succ!");
} else {
Serial.println("FP clear FP all lib fail! Please 'clear' again!!!");
}
}
else {
Serial.print("[ERROR] unknown cmd: ");
Serial.println(command);
}
// 清空残留串口数据，防止重复执行
while (Serial.available() > 0) Serial.read();
return true;
}
return false;
}
//读模组基本参数
int read_FP_info(void)
{
uint8_t response[32];
uint8_t index = 0;
uint32_t startTime = millis();
Serial.println("ZW101 FPM info:");
send_cmd(CMD_READ_SYSPARA);
// 等待包头 EF 01
while (millis() - startTime < 2000) {
if (fingerprintSerial.available()) {
uint8_t b = fingerprintSerial.read();
// 过滤杂散数据，等待包头开始字节 0xEF
if (index == 0 && b != 0xEF) continue;
// 如果是包头第二字节不是 0x01，则重置
if (index == 1 && b != 0x01) {
index = 0;
continue;
}
response[index++] = b;
// 包长度计算，等接收完数据包后跳出循环
if (index >= 9) {
// 根据协议，包长度字段在第7和8字节
uint16_t packetLen = ((uint16_t)response[7] << 8) | response[8];
// 包总长度 = 9(头+长度字段) + packetLen
if (index >= 9 + packetLen) break;
}
}
}
// 之后处理 response，长度就是 index
printResponse(response, index);
// 检查确认码
if (index >= 28 && response[9] == 0x00) {
uint16_t register_cnt = (uint16_t)(response[10]<<8) | response[11];
uint16_t fp_temp_size = (uint16_t)(response[12]<<8) | response[13];
uint16_t fp_lib_size = (uint16_t)(response[14]<<8) | response[15];
uint16_t score_level = (uint16_t)(response[16]<<8) | response[17];
uint32_t device_addr = (uint32_t)(response[18]<<24) | (response[19]<<16)| (response[20]<<8) | response[21];
uint16_t data_pack_size = (uint16_t)(response[22]<<8) | response[23];
if(0 == data_pack_size) {
data_pack_size = 32;
}
else if(1 == data_pack_size) {
data_pack_size = 64;
}
else if(2 == data_pack_size) {
data_pack_size = 128;
}
else if(3 == data_pack_size) {
data_pack_size = 256;
}
uint16_t baud_set = (uint16_t)(response[24]<<8) | response[25];
Serial.print("register cnt:");
Serial.println(register_cnt);
Serial.print("temp size:0x");
Serial.println(fp_temp_size,HEX);
Serial.print("lib size:");
Serial.println(fp_lib_size);
Serial.print("level:");
Serial.println(score_level);
Serial.print("devece address:0x");
Serial.println(device_addr,HEX);
Serial.print("data size:");
Serial.println(data_pack_size);
Serial.print("baud:");
Serial.println(baud_set*9600);
return 1; // 成功
} else {
Serial.println("ERROR: Invalid response or command failed.");
return 0; // 失败
}
}
int register_FP(void)
{
Serial.println("[DEBUG] register_FP start");
BUFFER_ID = 1;
while(BUFFER_ID <= 5) {
Serial.print("[DEBUG] Getting image for buffer ");
Serial.println(BUFFER_ID);
send_cmd(CMD_GET_IMAGE);
if (receiveResponse()) {
Serial.println("[DEBUG] Get image success");
} else {
Serial.println("[DEBUG] Get image fail, retrying...");
delay(1000);
continue;
}
Serial.println("[DEBUG] Generating char...");
send_cmd2(CMD_GEN_CHAR, BUFFER_ID);
if (receiveResponse()) {
Serial.println("[DEBUG] Gen char success");
BUFFER_ID++;
} else {
Serial.println("[DEBUG] Gen char fail, retrying...");
continue;
}
}
Serial.println("[DEBUG] Merging model...");
send_cmd(CMD_REG_MODEL);
if (receiveResponse()) {
Serial.println("[DEBUG] Merge model success");
} else {
Serial.println("[DEBUG] Merge model fail");
return 0;
}
Serial.println("[DEBUG] Storing template...");
BUFFER_ID = 1;
sendCommand(CMD_STORE_CHAR, BUFFER_ID, TEMPLATE_ID);
if (receiveResponse()) {
Serial.println("[DEBUG] Store template success");
} else {
Serial.println("[DEBUG] Store template fail");
return 0;
}
Serial.println("[DEBUG] register_FP success");
return 1;
}
//搜索指纹
int search_FP(void)
{
int serch_cnt = 0;
BUFFER_ID = 1;
while(serch_cnt <= 5) {
// 步骤1：获取图像
send_cmd(CMD_GET_IMAGE);
// 等待指纹模组响应
if (receiveResponse()) {
} else {
delay(1000);
continue;
}
// 步骤2：生成特征
send_cmd2(CMD_GEN_CHAR, BUFFER_ID);
if (receiveResponse()) {
break;
} else {
serch_cnt++;
delay(500);
continue;
}
}
// 步骤3：搜索指纹
BUFFER_ID = 1;
sendCommand1(CMD_SEARCH, BUFFER_ID, 1, 1);
if (receiveResponse()) {
return 1;
}
return 0;
}
//清空指纹库
int clear_FP_all_lib(void)
{
send_cmd(CMD_CLEAR_LIB);
if (receiveResponse()) {
return 1;
}
return 0;
}
// 发送指令包
void send_cmd(uint8_t cmd) {
uint8_t packet[12];
uint16_t length=3;
uint16_t checksum = 1+length+cmd;
// 构建指令包
packet[0] = HEADER_HIGH;
packet[1] = HEADER_LOW;
packet[2] = (DEVICE_ADDRESS >> 24) & 0xFF;
packet[3] = (DEVICE_ADDRESS >> 16) & 0xFF;
packet[4] = (DEVICE_ADDRESS >> 8) & 0xFF;
packet[5] = DEVICE_ADDRESS & 0xFF;
packet[6] = 0x01; // 包标识：命令包
packet[7] = (length >> 8) & 0xFF; // 包长度高字节
packet[8] = length & 0xFF; // 包长度低字节
packet[9] = cmd;
packet[10] = (checksum >> 8) & 0xFF;
packet[11] = checksum & 0xFF;
#if defined(HLK_DEBUG)
Serial.println("send1:");
printHex(packet,(2+4+3+length));
#endif
// 发送指令包
for (int i = 0; i < (2+4+3+length); i++) {
fingerprintSerial.write(packet[i]);
}
}
// 发送指令包
void send_cmd2(uint8_t cmd, uint8_t param1 ) {
uint8_t packet[13];
uint16_t length=4;
uint16_t checksum = 1+length+cmd + param1;
// 构建指令包
packet[0] = HEADER_HIGH;
packet[1] = HEADER_LOW;
packet[2] = (DEVICE_ADDRESS >> 24) & 0xFF;
packet[3] = (DEVICE_ADDRESS >> 16) & 0xFF;
packet[4] = (DEVICE_ADDRESS >> 8) & 0xFF;
packet[5] = DEVICE_ADDRESS & 0xFF;
packet[6] = 0x01; // 包标识：命令包
packet[7] = (length >> 8) & 0xFF; // 包长度高字节
packet[8] = length & 0xFF; // 包长度低字节
packet[9] = cmd;
packet[10] = param1;
packet[11] = (checksum >> 8) & 0xFF;
packet[12] = checksum & 0xFF;
#if defined(HLK_DEBUG)
Serial.println("send2:");
printHex(packet,(2+4+3+length));
#endif
// 发送指令包
for (int i = 0; i < (2+4+3+length); i++) {
fingerprintSerial.write(packet[i]);
}
}
// 发送指令包
void sendCommand(uint8_t cmd, uint8_t param1, uint16_t param2) {
uint8_t packet[15];
uint16_t length=6;
uint16_t checksum = 1+length+cmd + param1 + (param2 >> 8) + (param2 & 0xFF);
// 构建指令包
packet[0] = HEADER_HIGH;
packet[1] = HEADER_LOW;
packet[2] = (DEVICE_ADDRESS >> 24) & 0xFF;
packet[3] = (DEVICE_ADDRESS >> 16) & 0xFF;
packet[4] = (DEVICE_ADDRESS >> 8) & 0xFF;
packet[5] = DEVICE_ADDRESS & 0xFF;
packet[6] = 0x01; // 包标识：命令包
packet[7] = (length >> 8) & 0xFF; // 包长度高字节
packet[8] = length & 0xFF; // 包长度低字节
packet[9] = cmd;
packet[10] = param1;
packet[11] = (param2 >> 8) & 0xFF;
packet[12] = param2 & 0xFF;
packet[13] = (checksum >> 8) & 0xFF;
packet[14] = checksum & 0xFF;
#if defined(HLK_DEBUG)
Serial.println("send:");
printHex(packet,(2+4+3+length));
#endif
// 发送指令包
for (int i = 0; i < (2+4+3+length); i++) {
fingerprintSerial.write(packet[i]);
}
}
// 发送指令包
void sendCommand1(uint8_t cmd, uint8_t param1, uint16_t param2, uint16_t param3) {
uint8_t packet[17];
uint16_t length=8;
uint16_t checksum = 1+length+cmd + param1 + (param2 >> 8) + (param2 & 0xFF) + (param3 >> 8) + (param3 & 0xFF);
// 构建指令包
packet[0] = HEADER_HIGH;
packet[1] = HEADER_LOW;
packet[2] = (DEVICE_ADDRESS >> 24) & 0xFF;
packet[3] = (DEVICE_ADDRESS >> 16) & 0xFF;
packet[4] = (DEVICE_ADDRESS >> 8) & 0xFF;
packet[5] = DEVICE_ADDRESS & 0xFF;
packet[6] = 0x01; // 包标识：命令包
packet[7] = (length >> 8) & 0xFF; // 包长度高字节
packet[8] = length & 0xFF; // 包长度低字节
packet[9] = cmd;
packet[10] = param1;
packet[11] = (param2 >> 8) & 0xFF;
packet[12] = param2 & 0xFF;
packet[13] = (param3 >> 8) & 0xFF;
packet[14] = param3 & 0xFF;
packet[15] = (checksum >> 8) & 0xFF;
packet[16] = checksum & 0xFF;
#if defined(HLK_DEBUG)
Serial.println("send:");
printHex(packet,(2+4+3+length));
#endif
// 发送指令包
for (int i = 0; i < (2+4+3+length); i++) {
fingerprintSerial.write(packet[i]);
}
}
// 打印响应包
void printResponse(uint8_t *response, uint8_t length) {
Serial.print("Response:");
for (int i = 0; i < length; i++) {
if(response[i] < 0x10) Serial.print('0');
Serial.print(response[i], HEX);
Serial.print(" ");
}
Serial.println();
}
bool receiveResponse() {
uint8_t response[64];
uint8_t index = 0;
uint32_t startTime = millis();
// 先等待包头 EF 01
bool headerFound = false;
while (millis() - startTime < 2000) { // 延长等待时间到2秒
if (fingerprintSerial.available()) {
uint8_t b = fingerprintSerial.read();
if (!headerFound) {
if (index == 0 && b == 0xEF) {
response[index++] = b;
} else if (index == 1 && b == 0x01) {
response[index++] = b;
headerFound = true;
} else {
index = 0; // 重新开始找包头
}
} else {
response[index++] = b;
if (index >= 9) {
// 包长度在第7和8字节
uint16_t packetLen = ((uint16_t)response[7] << 8) | response[8];
if (index >= 9 + packetLen) {
// 收到完整包
break;
}
}
}
}
}
#if defined(HLK_DEBUG)
Serial.println("Received response:");
printResponse(response, index);
#endif
// 简单校验包头和确认码
if (index >= 12 && response[0] == 0xEF && response[1] == 0x01 && response[9] == 0x00) {
return true;
}
return false;
}
void updatefingerprint() {
if(!isInit) { //上电打印模组基本参数
isInit = true;
read_FP_info();
//命令使用说明
command_use();
}
//接收指令
run_command();
// delay(100);
}WEB网页
Web网页
借助ESP32C3的WIFI功能，实现局域网控制中心，使得数据可视化。
网页做了一些美化还有统计图，所以占用Flash比较多。
void handleRoot() {
String html = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>SmartLock控制中心</title>
<script>
let customDistance = 0.5;
async function update() {
const res = await fetch('/data');
const json = await res.json();
document.getElementById('avg10').innerText = json.avg10.toFixed(2);
document.getElementById('inside').innerText = json.timeInside;
document.getElementById('outside').innerText = json.timeOutside;
document.getElementById('pass').innerText = json.passCount;
document.getElementById('insideSwitch').innerText = json.countInsideSwitch;
document.getElementById('outsideSwitch').innerText = json.countOutsideSwitch;
document.getElementById('currentDistance').innerText = '当前自定义距离：' + json.customDistance.toFixed(2) + ' 米';
let points = json.stats;
let svg = '<g stroke="#ddd" stroke-width="0.5">';
for (let y = 0; y <= 100; y += 25) {
svg += '<line x1="0" y1="' + y + '" x2="100" y2="' + y + '" />';
}
svg += '</g>';
svg += '<g font-size="3" fill="#333">';
svg += '<text x="0" y="5">2.0m</text>';
svg += '<text x="0" y="30">1.5m</text>';
svg += '<text x="0" y="55">1.0m</text>';
svg += '<text x="0" y="80">0.5m</text>';
svg += '<text x="0" y="99">0.0m</text>';
svg += '</g>';
svg += '<polyline fill="none" stroke="blue" stroke-width="2" points="';
for (let i = 0; i < points.length; i++) {
let x = (i / (points.length - 1)) * 100;
let y = 100 - points[i] * 50;
svg += x + ',' + y + ' ';
}
svg += '" />';
for (let i = 0; i < points.length; i += 5) {
let x = (i / (points.length - 1)) * 100;
svg += '<text x="' + x + '" y="105" font-size="3" fill="#333">' + i + '</text>';
}
document.getElementById('graph').innerHTML = svg;
}
async function saveDistance() {
let val = parseFloat(document.getElementById('distanceInput').value);
if (isNaN(val) || val <= 0) {
alert('请输入有效的正数距离（单位：米）');
return;
}
const res = await fetch('/setDistance', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ distance: val })
});
if (res.ok) {
alert('距离设置成功: ' + val + ' 米');
document.getElementById('currentDistance').innerText = '当前自定义距离：' + val.toFixed(2) + ' 米';
document.getElementById('distanceInput').value = '';
} else {
alert('设置失败');
}
}
async function saveFingerprintText() {
let val = document.getElementById('fingerprintTextInput').value;
if (val.length === 0) {
alert('请输入有效的文本');
return;
}
const res = await fetch('/setFingerprintText', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ text: val })
});
if (res.ok) {
alert('文本设置成功: ' + val);
document.getElementById('fingerprintTextInput').value = val;
} else {
alert('设置失败');
}
}
setInterval(update, 1000);
window.onload = update;
</script>
<style>
body {
font-family: sans-serif;
padding: 1rem;
margin: 0;
background: #f9f9f9;
}
h1 {
color: #333;
}
.card {
background: white;
box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
padding: 1rem;
margin: 1rem 0;
border-radius: 8px;
}
svg {
background: #fff;
border: 1px solid #ccc;
width: 100%;
height: 80%;
}
input[type="number"] {
width: 80px;
padding: 4px;
margin-right: 8px;
border: 1px solid #ccc;
border-radius: 4px;
}
button {
padding: 5px 10px;
border: none;
background: #007BFF;
color: white;
border-radius: 4px;
cursor: pointer;
}
button:hover {
background: #0056b3;
}
@media (max-width: 600px) {
body {
font-size: 14px;
}
}
</style>
</head>
<body>
<h1>SmartLock控制中心</h1>
<p>版本号: v1.0</p>
<div class="card">
<div id="currentDistance">当前自定义距离：0.50 米</div>
<label>自定义距离 (米): </label>
<input type="number" id="distanceInput" step="0.01" min="0.01" value="" />
<button onclick="saveDistance()">保存</button>
</div>
<div class="card">
<div>指纹验证后输入的文本:</div>
<input type="text" id="fingerprintTextInput" />
<button onclick="saveFingerprintText()">保存</button>
</div>
<div class="card">
10样本平均距离：<strong><span id="avg10">--</span> m</strong>
</div>
<div class="card">
<svg id="graph" viewBox="0 0 100 110" preserveAspectRatio="none"></svg>
</div>
<div class="card">
<strong>工作时长：</strong><span id="inside">--</span> 秒<br />
<strong>休息时长：</strong><span id="outside">--</span> 秒<br />
<strong>在岗次数：</strong><span id="insideSwitch">--</span><br />
<strong>离岗次数：</strong><span id="outsideSwitch">--</span><br />
<strong>经过次数：</strong><span id="pass">--</span>
</div>
</body>
</html>
)rawliteral";
server.send(200, "text/html", html);
}页面数据接口
handleData()
数据API接口实现
void handleData() {
float sum = 0;
for (int i = 0; i < sampleCount; i++) sum += samples[i];
float avg10 = sampleCount ? sum / sampleCount : 0;
String json = "{";
json += "\"avg10\":" + String(avg10, 2);
json += ",\"timeInside\":" + String(timeInside / 1000.0, 2);
json += ",\"timeOutside\":" + String(timeOutside / 1000.0, 2);
json += ",\"passCount\":" + String(passCount);
json += ",\"countInsideSwitch\":" + String(countInsideSwitch);
json += ",\"countOutsideSwitch\":" + String(countOutsideSwitch);
json += ",\"customDistance\":" + String(customDistance, 2);
json += ",\"stats\": [";
for (size_t i = 0; i < stats.size(); i++) {
if (i > 0) json += ",";
json += String(stats[i].avg, 2);
}
json += "]}";
server.send(200, "application/json", json);
}页面配置接口
handleSetDistance()
配置接口API实现
void handleSetDistance() {
if (server.method() != HTTP_POST) {
server.send(405, "text/plain", "Method Not Allowed");
return;
}
if (!server.hasArg("plain")) {
server.send(400, "text/plain", "Bad Request");
return;
}
String body = server.arg("plain");
int idx = body.indexOf("\"distance\"");
if (idx < 0) {
server.send(400, "text/plain", "Bad Request");
return;
}
int colon = body.indexOf(':', idx);
int comma = body.indexOf(',', colon);
int endBracket = body.indexOf('}', colon);
int end = (comma > 0) ? (comma) : (endBracket);
String valStr = body.substring(colon + 1, end);
valStr.trim();
float val = valStr.toFloat();
if (val <= 0) {
server.send(400, "text/plain", "Invalid distance");
return;
}
customDistance = val;
countInside = 0;
countOutside = 0;
passCount = 0;
countInsideSwitch = 0;
countOutsideSwitch = 0;
timeInside = 0;
timeOutside = 0;
inside = false;
lastSampleTime = 0;
server.send(200, "text/plain", "OK");
}初始化
setup()
初始化部分
void setup() {
pinMode(MOTOR_PIN, OUTPUT);
digitalWrite(MOTOR_PIN, LOW); // 默认关闭
Serial.begin(SENSOR_BAUD);
while (!Serial) delay(10);
WiFi.softAP(ssid, password);
WiFi.softAPConfig(apIP, apIP, IPAddress(255,255,255,0));
Serial.print("AP IP=");
Serial.println(WiFi.softAPIP());
initfingerprint();
delay(1000);
server.on("/", handleRoot);
server.on("/data", handleData);
server.on("/setDistance", handleSetDistance);
server.on("/setFingerprintText", handleSetFingerprintText);
server.begin();
bleKeyboard.begin();
// 开机显示 "register" 并调用指纹注册函数
Wire.begin(SDA_PIN, SCL_PIN);
// OLED 初始化
display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
display.setRotation(2);
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("SmartLock");
display.setCursor(100, 22);
display.setTextSize(1);
display.println("v1.0");
display.display();
delay(3000);
while (true) {
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("Register");
display.setCursor(0, 22);
display.setTextSize(1);
display.println("Wait press...");
display.display();
// 调用指纹注册函数
int regResult = register_FP();
if (regResult == 1) {
// 注册成功，显示 "ok"
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("Register");
display.setCursor(0, 22);
display.setTextSize(1);
display.println("Succeed !");
display.display();
break; // 退出循环
} else {
// 注册失败，显示 "register again"
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("Register");
display.setCursor(0, 22);
display.setTextSize(1);
display.println("Press again...");
display.display();
delay(2000); // 显示2秒后重新尝试
}
}
}主循环
loop()
主体功能逻辑实现
void loop() {
readSensor();
server.handleClient();
// 计算分钟和秒数
unsigned long workSeconds = timeInside / 1000;
unsigned long relaxSeconds = timeOutside / 1000;
unsigned long workMinutes = workSeconds / 60;
unsigned long relaxMinutes = relaxSeconds / 60;
unsigned long workRemainingSeconds = workSeconds % 60;
unsigned long relaxRemainingSeconds = relaxSeconds % 60;
String timeStr = "Work Time: " + String(workMinutes) + ":" + (workRemainingSeconds < 10 ? "0" : "") + String(workRemainingSeconds);
String timeStr2 = "Relax Time: " + String(relaxMinutes) + ":" + (relaxRemainingSeconds < 10 ? "0" : "") + String(relaxRemainingSeconds);
// 设置字体（推荐小字体适配 128x32）
// 显示在屏幕第 1 行（Y 坐标约 12，取决于字体）
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println(timeStr.c_str());
display.setCursor(0, 22);
display.setTextSize(1);
display.println(timeStr2.c_str());
display.display();
}分区表
分区表
ESP32C3具备4MB，但是由于默认分区还预留了OTA分区，所以可用的很少。本项目不需要OTA升级所以这里我们修改分区表进行扩容。
去除原有的OTA预留空间，合并到主分区
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
factory, app, factory, 0x10000, 0x1C0000,
spiffs, data, spiffs, 0x1D0000, 0x220000,
coredump, data, coredump,0x3F0000, 0x10000,使用说明
配网
前面我们讲了我们使用的模块不带WIFI功能，上网是通过蓝牙共享网络实现的，所以这里配网相较于WIFI配网有所不同，你需要开启设备的蓝牙网络共享功能。
| Android16 | Windows11 |
|---|---|
 |  |
打开蓝牙，连接蓝牙设备名为SmartLock的设备 (已更名为ScreenLock)。