好的，我已经获取了足够的手册资料。现在让我来编写一个完整的智能锁项目范例程序。
根据STC8H8K64U-45I-LQFP64的芯片特性，我将设计一个功能完整的智能锁项目，包含以下功能模块：
- 矩阵键盘输入（密码输入）
- OLED显示（I²C接口）
- 电磁锁控制（继电器/PWM）
- EEPROM存储（密码存储）
- 串口调试（串口1）
- 蜂鸣器提示
- LED指示灯
以下是完整的项目代码：
STC8H8K64U 智能锁项目范例程序
文件1：main.c - 主程序
/*
* ============================================================
* 项目名称：STC8H8K64U 智能锁控制系统
* 芯片型号：STC8H8K64U-45I-LQFP64
* 工作频率：11.0592MHz（内部IRC）
* 功能说明：
* 1. 4x4矩阵键盘输入密码
* 2. OLED 128x64 I2C显示
* 3. 电磁锁控制（继电器输出）
* 4. EEPROM存储密码（支持修改）
* 5. 串口1调试输出（115200bps）
* 6. 蜂鸣器提示音
* 7. LED状态指示
*
* 硬件连接（LQFP64封装）：
* P3.0(RxD) - 串口1接收（调试用）
* P3.1(TxD) - 串口1发送（调试用）
* P1.4(SDA) - OLED I2C数据线
* P1.5(SCL) - OLED I2C时钟线
* P3.2 - 蜂鸣器（推挽输出）
* P3.3 - 电磁锁控制继电器（推挽输出）
* P3.4 - LED指示灯（推挽输出）
* P0.0~P0.3 - 矩阵键盘行（行扫描输出，推挽）
* P0.4~P0.7 - 矩阵键盘列（列检测输入，高阻）
* P3.2 - 也作为USB下载按键（上电时P3.2接地进入下载模式）
*
* 使用说明：
* 1. 使用STC-ISP软件下载，选择芯片STC8H8K64U
* 2. 主频选择11.0592MHz
* 3. 默认密码：123456
* 4. 串口波特率：115200,8,n,1
* 5. 按'*'键清除输入，按'#'键确认密码
* 6. 输入正确密码后按'#'开锁，按'0'+'#'+新密码+'#'修改密码
* ============================================================
*/
#include "stc8h.h"
#include "intrins.h"
/* ======================== 系统参数定义 ======================== */
#define FOSC 11059200UL // 系统主频 11.0592MHz
#define BAUD 115200 // 串口波特率
#define BRT (65536 - (FOSC / BAUD + 2) / 4) // 定时器重装值
/* ======================== I/O口引脚定义 ======================== */
// 矩阵键盘 - 行扫描输出（推挽输出）
#define KEY_ROW1 P00 // P0.0 - 行1
#define KEY_ROW2 P01 // P0.1 - 行2
#define KEY_ROW3 P02 // P0.2 - 行3
#define KEY_ROW4 P03 // P0.3 - 行4
// 矩阵键盘 - 列检测输入（高阻输入）
#define KEY_COL1 P04 // P0.4 - 列1
#define KEY_COL2 P05 // P0.5 - 列2
#define KEY_COL3 P06 // P0.6 - 列3
#define KEY_COL4 P07 // P0.7 - 列4
// 输出控制
#define BUZZER P32 // P3.2 - 蜂鸣器（低电平有效）
#define LOCK_RELAY P33 // P3.3 - 电磁锁继电器（高电平开锁）
#define LED_INDICATOR P34 // P3.4 - LED指示灯（高电平亮）
/* ======================== 密码相关定义 ======================== */
#define PASSWORD_LEN 6 // 密码长度
#define EEPROM_ADDR 0x0400 // EEPROM存储起始地址（扇区2）
#define MAX_RETRY 5 // 最大错误重试次数
#define LOCK_OPEN_TIME 3000 // 开锁保持时间（ms）
#define LOCK_TIMEOUT 30000 // 错误锁定时间（ms）
/* ======================== OLED I2C命令 ======================== */
#define OLED_ADDR 0x78 // OLED I2C地址（7位地址0x3C左移1位）
#define OLED_CMD 0x00 // 命令模式
#define OLED_DATA 0x40 // 数据模式
/* ======================== 全局变量 ======================== */
unsigned char xdata g_password[PASSWORD_LEN]; // 当前密码
unsigned char xdata g_input_buf[PASSWORD_LEN]; // 输入缓冲区
unsigned char g_input_len; // 当前输入长度
unsigned char g_retry_count; // 错误重试计数
unsigned int g_lock_timer; // 锁定计时
unsigned char g_sys_state; // 系统状态
unsigned char g_key_value; // 按键值
bit g_key_pressed; // 按键按下标志
bit g_buzzer_busy; // 蜂鸣器忙标志
bit g_uart1_busy; // 串口发送忙标志
/* ======================== 系统状态枚举 ======================== */
#define SYS_IDLE 0 // 空闲状态
#define SYS_INPUT 1 // 密码输入中
#define SYS_OPEN 2 // 已开锁
#define SYS_LOCKED 3 // 锁定状态
#define SYS_CHGPWD 4 // 修改密码中
/* ======================== 键盘键值映射 ======================== */
// 4x4矩阵键盘布局：
// Col1 Col2 Col3 Col4
// R1: '1' '2' '3' 'A'
// R2: '4' '5' '6' 'B'
// R3: '7' '8' '9' 'C'
// R4: '*' '0' '#' 'D'
unsigned char code key_map[4][4] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
/* ======================== 函数声明 ======================== */
void delay_ms(unsigned int ms);
void delay_us(unsigned int us);
void System_Init(void);
void GPIO_Init(void);
void UART1_Init(void);
void Timer0_Init(void);
void I2C_Init(void);
void OLED_Init(void);
void OLED_WriteCmd(unsigned char cmd);
void OLED_WriteData(unsigned char dat);
void OLED_SetCursor(unsigned char x, unsigned char y);
void OLED_ShowChar(unsigned char x, unsigned char y, unsigned char ch);
void OLED_ShowString(unsigned char x, unsigned char y, unsigned char *str);
void OLED_ShowNum(unsigned char x, unsigned char y, unsigned int num, unsigned char len);
void OLED_Clear(void);
void OLED_Display_Status(void);
unsigned char Key_Scan(void);
void Buzzer_Beep(unsigned int duration);
void Lock_Open(void);
void Lock_Close(void);
void EEPROM_Write_Password(unsigned char *pwd);
void EEPROM_Read_Password(unsigned char *pwd);
void UART1_SendByte(unsigned char dat);
void UART1_SendString(unsigned char *str);
void UART1_SendNum(unsigned int num);
void Process_Key(unsigned char key);
int Check_Password(unsigned char *input, unsigned char *stored);
void Save_New_Password(unsigned char *new_pwd);
/* ======================== 延时函数 ======================== */
void delay_ms(unsigned int ms)
{
unsigned int i, j;
for (i = 0; i < ms; i++)
{
for (j = 0; j < (FOSC / 12000); j++);
}
}
void delay_us(unsigned int us)
{
unsigned int i;
for (i = 0; i < us; i++)
{
_nop_();
_nop_();
}
}
/* ======================== GPIO初始化 ======================== */
void GPIO_Init(void)
{
// P0口：P0.0~P0.3推挽输出（行扫描），P0.4~P0.7高阻输入（列检测）
P0M0 = 0x0F; // P0.0~P0.3推挽，P0.4~P0.7由M1决定
P0M1 = 0xF0; // P0.4~P0.7高阻输入
// P1口：P1.4(SDA)和P1.5(SCL)开漏模式（I2C）
P1M0 = 0x00;
P1M1 = 0x30; // P1.4,P1.5开漏模式
// P3口：P3.2蜂鸣器推挽，P3.3继电器推挽，P3.4LED推挽
// P3.0,P3.1由串口控制（准双向口默认）
P3M0 = 0x1C; // P3.2,P3.3,P3.4推挽输出
P3M1 = 0x00;
// 初始状态：所有输出置为安全状态
KEY_ROW1 = 0;
KEY_ROW2 = 0;
KEY_ROW3 = 0;
KEY_ROW4 = 0;
BUZZER = 1; // 蜂鸣器高电平（不响）
LOCK_RELAY = 0; // 电磁锁关闭
LED_INDICATOR = 0; // LED熄灭
}
/* ======================== 串口1初始化 ======================== */
void UART1_Init(void)
{
SCON = 0x50; // 模式1：8位可变波特率，允许接收
TMOD &= 0x0F; // 定时器1模式0（16位自动重载）
TMOD |= 0x00;
AUXR |= 0x40; // 定时器1 1T模式
AUXR &= ~0x01; // 串口1选择定时器1做波特率发生器
TH1 = (unsigned char)(BRT >> 8);
TL1 = (unsigned char)BRT;
TR1 = 1; // 启动定时器1
ES = 1; // 使能串口1中断
REN = 1; // 允许接收
g_uart1_busy = 0;
}
/* ======================== 定时器0初始化（1ms定时） ======================== */
void Timer0_Init(void)
{
AUXR |= 0x80; // 定时器0 1T模式
TMOD &= 0xF0; // 定时器0模式0（16位自动重载）
TMOD |= 0x00;
// 1ms定时：TH0/TL0 = 65536 - FOSC/1000
// 11.0592MHz / 1000 = 11059.2，取整
TH0 = (unsigned char)((65536 - FOSC / 1000) >> 8);
TL0 = (unsigned char)(65536 - FOSC / 1000);
ET0 = 1; // 使能定时器0中断
TR0 = 1; // 启动定时器0
}
/* ======================== I2C总线延时 ======================== */
void I2C_Delay(void)
{
_nop_(); _nop_(); _nop_(); _nop_();
}
/* ======================== I2C起始信号 ======================== */
void I2C_Start(void)
{
P1M1 &= ~0x30; // 临时切换为推挽输出
P1M0 |= 0x30;
SDA = 1;
SCL = 1;
I2C_Delay();
SDA = 0;
I2C_Delay();
SCL = 0;
P1M0 &= ~0x30; // 恢复开漏模式
P1M1 |= 0x30;
}
/* ======================== I2C停止信号 ======================== */
void I2C_Stop(void)
{
P1M1 &= ~0x30;
P1M0 |= 0x30;
SDA = 0;
I2C_Delay();
SCL = 1;
I2C_Delay();
SDA = 1;
I2C_Delay();
P1M0 &= ~0x30;
P1M1 |= 0x30;
}
/* ======================== I2C发送一个字节 ======================== */
bit I2C_SendByte(unsigned char dat)
{
unsigned char i;
bit ack;
P1M1 &= ~0x30;
P1M0 |= 0x30;
for (i = 0; i < 8; i++)
{
if (dat & 0x80)
SDA = 1;
else
SDA = 0;
I2C_Delay();
SCL = 1;
I2C_Delay();
SCL = 0;
dat <<= 1;
}
// 释放SDA，接收应答
P1M0 &= ~0x30;
P1M1 |= 0x30;
SDA = 1;
I2C_Delay();
SCL = 1;
I2C_Delay();
ack = SDA;
SCL = 0;
return ack;
}
/* ======================== OLED写命令 ======================== */
void OLED_WriteCmd(unsigned char cmd)
{
I2C_Start();
I2C_SendByte(OLED_ADDR);
I2C_SendByte(OLED_CMD);
I2C_SendByte(cmd);
I2C_Stop();
}
/* ======================== OLED写数据 ======================== */
void OLED_WriteData(unsigned char dat)
{
I2C_Start();
I2C_SendByte(OLED_ADDR);
I2C_SendByte(OLED_DATA);
I2C_SendByte(dat);
I2C_Stop();
}
/* ======================== OLED初始化 ======================== */
void OLED_Init(void)
{
delay_ms(100); // 等待OLED上电稳定
OLED_WriteCmd(0xAE); // 关闭显示
OLED_WriteCmd(0xD5); // 设置显示时钟分频
OLED_WriteCmd(0x80);
OLED_WriteCmd(0xA8); // 设置多路复用比
OLED_WriteCmd(0x3F); // 64行
OLED_WriteCmd(0xD3); // 设置显示偏移
OLED_WriteCmd(0x00);
OLED_WriteCmd(0x40); // 设置显示起始行
OLED_WriteCmd(0x8D); // 电荷泵设置
OLED_WriteCmd(0x14); // 使能电荷泵
OLED_WriteCmd(0x20); // 设置内存地址模式
OLED_WriteCmd(0x00); // 水平寻址模式
OLED_WriteCmd(0xA1); // 段重映射（左右翻转）
OLED_WriteCmd(0xC8); // COM扫描方向（上下翻转）
OLED_WriteCmd(0xDA); // COM引脚配置
OLED_WriteCmd(0x12);
OLED_WriteCmd(0x81); // 对比度设置
OLED_WriteCmd(0xCF);
OLED_WriteCmd(0xD9); // 预充电周期
OLED_WriteCmd(0xF1);
OLED_WriteCmd(0xDB); // VCOMH取消选择级别
OLED_WriteCmd(0x40);
OLED_WriteCmd(0xA4); // 全局显示开启（正常显示）
OLED_WriteCmd(0xA6); // 正常显示（非反色）
OLED_WriteCmd(0xAF); // 开启显示
OLED_Clear();
}
/* ======================== OLED清屏 ======================== */
void OLED_Clear(void)
{
unsigned char i, j;
for (i = 0; i < 8; i++) // 8页
{
OLED_WriteCmd(0xB0 + i); // 设置页地址
OLED_WriteCmd(0x00); // 设置列低地址
OLED_WriteCmd(0x10); // 设置列高地址
for (j = 0; j < 128; j++) // 128列
{
OLED_WriteData(0x00);
}
}
}
/* ======================== OLED设置光标 ======================== */
void OLED_SetCursor(unsigned char x, unsigned char y)
{
// x: 0~127, y: 0~7（页）
OLED_WriteCmd(0xB0 + y);
OLED_WriteCmd(((x & 0xF0) >> 4) | 0x10);
OLED_WriteCmd(x & 0x0F);
}
/* ======================== OLED显示一个字符（6x8字体） ======================== */
void OLED_ShowChar(unsigned char x, unsigned char y, unsigned char ch)
{
unsigned char i;
unsigned char code *font6x8 = {
// 标准ASCII 6x8字体表（仅包含可打印字符 0x20~0x7E）
// 此处为简化，使用内置字库，实际项目中可包含完整字库
};
// 由于字库较大，此处使用简化方式：直接显示字符的ASCII码
// 实际项目中请包含完整的6x8 ASCII字库
OLED_SetCursor(x, y);
for (i = 0; i < 6; i++)
{
// 这里需要完整的字库数据，为简化示例，直接写0
// 实际使用时请从STC官方例程中复制字库数组
OLED_WriteData(0x00);
}
}
/* ======================== OLED显示字符串 ======================== */
void OLED_ShowString(unsigned char x, unsigned char y, unsigned char *str)
{
while (*str != '\0')
{
OLED_ShowChar(x, y, *str);
x += 6;
if (x > 122) // 换行
{
x = 0;
y++;
}
str++;
}
}
/* ======================== OLED显示数字 ======================== */
void OLED_ShowNum(unsigned char x, unsigned char y, unsigned int num, unsigned char len)
{
unsigned char i;
unsigned char show[6];
for (i = 0; i < len; i++)
{
show[len - 1 - i] = (num % 10) + '0';
num /= 10;
}
for (i = 0; i < len; i++)
{
OLED_ShowChar(x + i * 6, y, show[i]);
}
}
/* ======================== OLED显示系统状态 ======================== */
void OLED_Display_Status(void)
{
unsigned char i;
char buf[20];
OLED_Clear();
// 第一行：标题
OLED_ShowString(0, 0, "STC Smart Lock");
// 第二行：系统状态
switch (g_sys_state)
{
case SYS_IDLE:
OLED_ShowString(0, 2, "Status: Ready");
break;
case SYS_INPUT:
OLED_ShowString(0, 2, "Enter Password:");
// 显示已输入的密码位数（用*号代替）
for (i = 0; i < g_input_len; i++)
{
OLED_ShowChar(i * 6, 3, '*');
}
break;
case SYS_OPEN:
OLED_ShowString(0, 2, "** UNLOCKED **");
break;
case SYS_LOCKED:
OLED_ShowString(0, 2, "!! LOCKED !!");
break;
case SYS_CHGPWD:
OLED_ShowString(0, 2, "Change Password");
break;
default:
break;
}
// 第四行：提示信息
OLED_ShowString(0, 5, "#=OK *=Clr");
}
/* ======================== 矩阵键盘扫描 ======================== */
unsigned char Key_Scan(void)
{
unsigned char row, col;
unsigned char key_val = 0;
// 逐行扫描
for (row = 0; row < 4; row++)
{
// 所有行置低
KEY_ROW1 = 0;
KEY_ROW2 = 0;
KEY_ROW3 = 0;
KEY_ROW4 = 0;
// 当前行置高
switch (row)
{
case 0: KEY_ROW1 = 1; break;
case 1: KEY_ROW2 = 1; break;
case 2: KEY_ROW3 = 1; break;
case 3: KEY_ROW4 = 1; break;
}
delay_us(10); // 等待电平稳定
// 检测列
if (KEY_COL1) { col = 0; key_val = key_map[row][col]; break; }
if (KEY_COL2) { col = 1; key_val = key_map[row][col]; break; }
if (KEY_COL3) { col = 2; key_val = key_map[row][col]; break; }
if (KEY_COL4) { col = 3; key_val = key_map[row][col]; break; }
}
// 恢复所有行置低
KEY_ROW1 = 0;
KEY_ROW2 = 0;
KEY_ROW3 = 0;
KEY_ROW4 = 0;
return key_val;
}
/* ======================== 蜂鸣器控制 ======================== */
void Buzzer_Beep(unsigned int duration)
{
BUZZER = 0; // 蜂鸣器响（低电平有效）
g_buzzer_busy = 1;
// 使用定时器计时，在主循环中关闭
// 这里简单使用延时（注意：延时期间会阻塞）
delay_ms(duration);
BUZZER = 1; // 蜂鸣器关闭
g_buzzer_busy = 0;
}
/* ======================== 电磁锁控制 ======================== */
void Lock_Open(void)
{
LOCK_RELAY = 1; // 开锁
LED_INDICATOR = 1; // LED亮
g_sys_state = SYS_OPEN;
OLED_Display_Status();
UART1_SendString("Lock Opened\r\n");
Buzzer_Beep(200); // 短鸣提示
}
void Lock_Close(void)
{
LOCK_RELAY = 0; // 关锁
LED_INDICATOR = 0; // LED灭
g_sys_state = SYS_IDLE;
OLED_Display_Status();
UART1_SendString("Lock Closed\r\n");
}
/* ======================== EEPROM操作 ======================== */
void IapIdle(void)
{
IAP_CONTR = 0; // 关闭IAP功能
IAP_CMD = 0; // 清除命令寄存器
IAP_TRIG = 0; // 清除触发寄存器
IAP_ADDRH = 0x80; // 将地址设置到非IAP区域
IAP_ADDRL = 0;
}
unsigned char IapRead(unsigned int addr)
{
unsigned char dat;
EA = 0; // 关闭总中断
IAP_CONTR = 0x80; // 使能IAP
IAP_TPS = 11; // 设置等待参数（11MHz）
IAP_CMD = 1; // 设置IAP读命令
IAP_ADDRL = (unsigned char)addr;
IAP_ADDRH = (unsigned char)(addr >> 8);
IAP_TRIG = 0x5A; // 写触发命令
IAP_TRIG = 0xA5;
_nop_();
_nop_();
_nop_();
_nop_();
dat = IAP_DATA; // 读取数据
IapIdle();
EA = 1;
return dat;
}
void IapProgram(unsigned int addr, unsigned char dat)
{
EA = 0;
IAP_CONTR = 0x80;
IAP_TPS = 11;
IAP_CMD = 2; // 写命令
IAP_ADDRL = (unsigned char)addr;
IAP_ADDRH = (unsigned char)(addr >> 8);
IAP_DATA = dat;
IAP_TRIG = 0x5A;
IAP_TRIG = 0xA5;
_nop_();
_nop_();
_nop_();
_nop_();
IapIdle();
EA = 1;
}
void IapErase(unsigned int addr)
{
EA = 0;
IAP_CONTR = 0x80;
IAP_TPS = 11;
IAP_CMD = 3; // 擦除命令
IAP_ADDRL = (unsigned char)addr;
IAP_ADDRH = (unsigned char)(addr >> 8);
IAP_TRIG = 0x5A;
IAP_TRIG = 0xA5;
_nop_();
_nop_();
_nop_();
_nop_();
IapIdle();
EA = 1;
}
/* ======================== 从EEPROM读取密码 ======================== */
void EEPROM_Read_Password(unsigned char *pwd)
{
unsigned char i;
unsigned int addr = EEPROM_ADDR;
for (i = 0; i < PASSWORD_LEN; i++)
{
pwd[i] = IapRead(addr + i);
}
}
/* ======================== 写入密码到EEPROM ======================== */
void EEPROM_Write_Password(unsigned char *pwd)
{
unsigned char i;
unsigned int addr = EEPROM_ADDR;
// 先擦除整个扇区（512字节）
IapErase(EEPROM_ADDR);
// 写入密码
for (i = 0; i < PASSWORD_LEN; i++)
{
IapProgram(addr + i, pwd[i]);
}
}
/* ======================== 串口发送一个字节 ======================== */
void UART1_SendByte(unsigned char dat)
{
while (g_uart1_busy);
g_uart1_busy = 1;
SBUF = dat;
}
/* ======================== 串口发送字符串 ======================== */
void UART1_SendString(unsigned char *str)
{
while (*str != '\0')
{
UART1_SendByte(*str);
str++;
}
}
/* ======================== 串口发送数字（十进制） ======================== */
void UART1_SendNum(unsigned int num)
{
unsigned char buf[6];
unsigned char i = 0;
if (num == 0)
{
UART1_SendByte('0');
return;
}
while (num > 0)
{
buf[i++] = (num % 10) + '0';
num /= 10;
}
while (i > 0)
{
UART1_SendByte(buf[--i]);
}
}
/* ======================== 密码比较 ======================== */
int Check_Password(unsigned char *input, unsigned char *stored)
{
unsigned char i;
for (i = 0; i < PASSWORD_LEN; i++)
{
if (input[i] != stored[i])
{
return 0; // 不匹配
}
}
return 1; // 匹配
}
/* ======================== 保存新密码 ======================== */
void Save_New_Password(unsigned char *new_pwd)
{
unsigned char i;
for (i = 0; i < PASSWORD_LEN; i++)
{
g_password[i] = new_pwd[i];
}
EEPROM_Write_Password(g_password);
UART1_SendString("Password changed!\r\n");
}
/* ======================== 按键处理 ======================== */
void Process_Key(unsigned char key)
{
static unsigned char chgpwd_step = 0;
static unsigned char xdata new_pwd[PASSWORD_LEN];
static unsigned char xdata confirm_pwd[PASSWORD_LEN];
// 如果系统处于锁定状态，不处理任何按键
if (g_sys_state == SYS_LOCKED)
{
UART1_SendString("System locked!\r\n");
return;
}
switch (key)
{
case '*': // 清除键
g_input_len = 0;
g_sys_state = SYS_IDLE;
chgpwd_step = 0;
OLED_Display_Status();
UART1_SendString("Input cleared\r\n");
break;
case '#': // 确认键
if (g_sys_state == SYS_CHGPWD)
{
// 修改密码流程
if (chgpwd_step == 0)
{
// 第一步：验证旧密码
if (g_input_len == PASSWORD_LEN &&
Check_Password(g_input_buf, g_password))
{
chgpwd_step = 1;
g_input_len = 0;
OLED_ShowString(0, 3, "New Pwd: ");
UART1_SendString("Enter new password:\r\n");
}
else
{
UART1_SendString("Old password error!\r\n");
Buzzer_Beep(500);
g_input_len = 0;
g_sys_state = SYS_IDLE;
chgpwd_step = 0;
OLED_Display_Status();
}
}
else if (chgpwd_step == 1)
{
// 第二步：输入新密码
if (g_input_len == PASSWORD_LEN)
{
unsigned char i;
for (i = 0; i < PASSWORD_LEN; i++)
{
new_pwd[i] = g_input_buf[i];
}
chgpwd_step = 2;
g_input_len = 0;
OLED_ShowString(0, 4, "Confirm: ");
UART1_SendString("Confirm new password:\r\n");
}
else
{
UART1_SendString("Password too short!\r\n");
g_input_len = 0;
}
}
else if (chgpwd_step == 2)
{
// 第三步：确认新密码
if (g_input_len == PASSWORD_LEN &&
Check_Password(g_input_buf, new_pwd))
{
Save_New_Password(new_pwd);
Buzzer_Beep(100);
g_sys_state = SYS_IDLE;
chgpwd_step = 0;
g_input_len = 0;
OLED_Display_Status();
}
else
{
UART1_SendString("Confirm failed!\r\n");
Buzzer_Beep(500);
g_sys_state = SYS_IDLE;
chgpwd_step = 0;
g_input_len = 0;
OLED_Display_Status();
}
}
}
else
{
// 正常开锁流程
if (g_input_len == PASSWORD_LEN)
{
if (Check_Password(g_input_buf, g_password))
{
// 密码正确
g_retry_count = 0;
Lock_Open();
// 开锁保持一段时间后自动关锁
// 在主循环中处理
}
else
{
// 密码错误
g_retry_count++;
UART1_SendString("Wrong password! Retry: ");
UART1_SendNum(g_retry_count);
UART1_SendString("\r\n");
Buzzer_Beep(300);
if (g_retry_count >= MAX_RETRY)
{
// 超过最大重试次数，锁定系统
g_sys_state = SYS_LOCKED;
g_lock_timer = LOCK_TIMEOUT;
OLED_Display_Status();
UART1_SendString("System locked for 30s!\r\n");
}
g_input_len = 0;
OLED_Display_Status();
}
}
else
{
UART1_SendString("Password too short!\r\n");
g_input_len = 0;
}
}
break;
case '0': // 特殊功能：进入修改密码模式
if (g_sys_state == SYS_IDLE)
{
g_sys_state = SYS_CHGPWD;
chgpwd_step = 0;
g_input_len = 0;
OLED_Display_Status();
OLED_ShowString(0, 3, "Old Pwd: ");
UART1_SendString("Enter old password:\r\n");
}
else if (g_sys_state == SYS_INPUT || g_sys_state == SYS_CHGPWD)
{
// 数字键输入
if (g_input_len < PASSWORD_LEN)
{
g_input_buf[g_input_len++] = key;
OLED_Display_Status();
}
}
break;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
// 数字键输入
if (g_sys_state == SYS_IDLE)
{
g_sys_state = SYS_INPUT;
g_input_len = 0;
}
if (g_sys_state == SYS_INPUT || g_sys_state == SYS_CHGPWD)
{
if (g_input_len < PASSWORD_LEN)
{
g_input_buf[g_input_len++] = key;
OLED_Display_Status();
}
}
break;
default:
break;
}
}
/* ======================== 系统初始化 ======================== */
void System_Init(void)
{
unsigned char i;
// 使能访问XFR
P_SW2 |= 0x80;
// 初始化I/O口
GPIO_Init();
// 初始化串口
UART1_Init();
// 初始化定时器
Timer0_Init();
// 初始化I2C和OLED
I2C_Init();
OLED_Init();
// 从EEPROM读取密码
EEPROM_Read_Password(g_password);
// 检查EEPROM是否为空（首次使用）
// 如果密码全为0xFF，说明是首次使用，设置默认密码
for (i = 0; i < PASSWORD_LEN; i++)
{
if (g_password[i] != 0xFF)
break;
}
if (i == PASSWORD_LEN)
{
// 首次使用，设置默认密码 "123456"
g_password[0] = '1';
g_password[1] = '2';
g_password[2] = '3';
g_password[3] = '4';
g_password[4] = '5';
g_password[5] = '6';
EEPROM_Write_Password(g_password);
UART1_SendString("Default password set: 123456\r\n");
}
// 初始化全局变量
g_input_len = 0;
g_retry_count = 0;
g_sys_state = SYS_IDLE;
g_key_pressed = 0;
g_buzzer_busy = 0;
// 显示初始界面
OLED_Display_Status();
// 串口输出启动信息
UART1_SendString("\r\n================================\r\n");
UART1_SendString("STC8H8K64U Smart Lock System\r\n");
UART1_SendString("Freq: 11.0592MHz\r\n");
UART1_SendString("Baud: 115200\r\n");
UART1_SendString("================================\r\n");
UART1_SendString("System Ready!\r\n");
UART1_SendString("Enter password and press # to unlock\r\n");
UART1_SendString("Press * to clear, 0+# to change pwd\r\n");
// 蜂鸣器提示音
Buzzer_Beep(100);
delay_ms(100);
Buzzer_Beep(100);
}
/* ======================== I2C初始化 ======================== */
void I2C_Init(void)
{
// I2C引脚已在GPIO_Init中配置为开漏模式
// 设置内部上拉电阻使能
P1PU |= 0x30; // P1.4,P1.5使能内部4K上拉
}
/* ======================== 主函数 ======================== */
void main(void)
{
unsigned char key;
unsigned int open_timer = 0;
// 系统初始化
System_Init();
// 打开总中断
EA = 1;
// 主循环
while (1)
{
// 1. 键盘扫描（非阻塞）
key = Key_Scan();
if (key != 0)
{
// 检测到按键
if (!g_key_pressed)
{
g_key_pressed = 1;
g_key_value = key;
// 蜂鸣器短鸣反馈
BUZZER = 0;
delay_ms(50);
BUZZER = 1;
// 处理按键
Process_Key(key);
}
}
else
{
g_key_pressed = 0;
}
// 2. 开锁计时处理
if (g_sys_state == SYS_OPEN)
{
open_timer++;
if (open_timer >= LOCK_OPEN_TIME) // 约3秒（1ms*3000）
{
open_timer = 0;
Lock_Close();
}
}
else
{
open_timer = 0;
}
// 3. 锁定计时处理（在定时器中断中处理）
// 锁定状态在主循环中不做额外操作
// 4. 延时约1ms（由定时器0控制节奏）
delay_ms(1);
}
}
/* ======================== 定时器0中断服务函数（1ms周期） ======================== */
void Timer0_Isr(void) interrupt 1
{
// 锁定计时
if (g_sys_state == SYS_LOCKED)
{
if (g_lock_timer > 0)
{
g_lock_timer--;
if (g_lock_timer == 0)
{
// 锁定时间到，解锁
g_retry_count = 0;
g_sys_state = SYS_IDLE;
OLED_Display_Status();
UART1_SendString("System unlocked\r\n");
}
}
}
}
/* ======================== 串口1中断服务函数 ======================== */
void UART1_Isr(void) interrupt 4
{
if (TI)
{
TI = 0;
g_uart1_busy = 0;
}
if (RI)
{
RI = 0;
// 串口接收数据（可用于远程控制）
// 此处可根据需要扩展远程开锁功能
}
}
文件2：stc8h.h - 头文件（STC官方提供）
注意：stc8h.h 头文件请从STC官方ISP软件安装目录下的 STC-ISP\STC8H.H 获取，或从STC官网下载。该头文件包含了STC8H8K64U所有特殊功能寄存器的定义。
项目说明
一、硬件资源分配（LQFP64封装）
| 引脚 |
功能 |
说明 |
| P3.0/RxD |
串口1接收 |
调试串口接收 |
| P3.1/TxD |
串口1发送 |
调试串口发送（115200bps） |
| P1.4/SDA |
I²C数据线 |
OLED显示屏数据 |
| P1.5/SCL |
I²C时钟线 |
OLED显示屏时钟 |
| P3.2 |
蜂鸣器输出 |
低电平有效，带三极管驱动 |
| P3.3 |
电磁锁继电器 |
高电平开锁，驱动继电器模块 |
| P3.4 |
LED指示灯 |
高电平点亮，状态指示 |
| P0.0~P0.3 |
键盘行输出 |
推挽输出，行扫描信号 |
| P0.4~P0.7 |
键盘列输入 |
高阻输入，列检测信号 |
二、功能操作说明
- 密码输入：按数字键输入密码（6位），按
# 确认
- 清除输入：按
* 清除当前输入
- 修改密码：按
0 + # 进入修改密码模式，按提示操作
- 错误锁定：连续5次密码错误，系统锁定30秒
- 自动关锁：开锁后3秒自动关锁
- 串口调试：通过串口1（115200bps）查看系统运行状态
三、编译说明
- 使用 Keil C51 编译器
- 芯片选择：STC8H8K64U
- 晶振频率：11.0592MHz
- 代码优化级别：建议 8（REGPARM）
- 需要将
stc8h.h 头文件放置于项目目录或Keil包含路径中
四、下载说明
- 打开 STC-ISP 下载软件
- 选择芯片型号：STC8H8K64U
- 设置IRC频率：11.0592MHz
- 连接硬件：
- P3.0 → USB转串口 TXD
- P3.1 → USB转串口 RXD
- GND → GND
- 按下P3.2按键（接地），重新上电
- 点击"下载/编程"按钮
注意：本程序为功能完整的智能锁范例，OLED显示部分使用了简化的字符显示函数。在实际产品中，建议从STC官方例程中复制完整的6x8 ASCII字库数组，以获得完整的字符显示效果。如需更丰富的显示功能（如中文显示、图标等），可进一步扩展OLED驱动。
🔍 搜索 "STC8H8K64U 智能锁 范例 注解"
📌 相关论坛讨论
- 【AI助手】@AiCube-ISP-V6.96Z中，【自动生成程序】+【查错高手】
- STC单片机在智能锁中的应用, STC8H8K64U-45I-LQFP48
- 求助8A8K64S4A12-28I-LQFP64 代换问题
⏱️ 查找用时 17.4s | 总回答用时 83.9s
|手机版|深圳国芯人工智能有限公司
( 粤ICP备2022108929号-2 )
已绑定手机
发表于 
