初学单片机-单键密码锁制作日志-遇到问题

biying · 发表于 2014-4-11 09:56:05

本帖最后由 biying 于 2014-4-11 11:29 编辑

家里人有时会忘记带大门钥匙，甚至摩托车钥匙忘记拔下来，我就想搞个密码锁上去，不用钥匙了，这是大门电控板，用的是两个继电器控制卷帘门电机的正反转，板上三个按钮在一起的分别是开门、停止、关门，另外一边的那个按钮是添加遥控器用的。

。

我打算用单片机直接控制原板上的按钮，只要输出1秒低电平就可以了。之前在淘宝上找到一个卖成品的，可以设置成自锁和互锁，拍好后卖家说没芯片了，用汇编写的，我想请它重新帮我写下，他说太麻烦了，原来用的芯片一直没货。另一款是专门用在摩托车上的，是成品，用的是stc15F104E控制,就是这种：

，

我嫌它输入密码太慢，得按着开关数LED灯闪的次数，还有就是放一段时间后密码竟然输入不对了，可能是芯片不稳定。于是就萌发了我制作这么一个单片机来控制大门中控锁和摩托车锁的念头。人机交互打算用一个带灯的开关，通过灯的状态来反馈单按键的输入状态。为什么选单按键，因为好安装，不容易被破坏，容易防水，可以做的掩蔽。在多种单片机中，我选了AVR，原因之一是我的高频烙铁用的就是M8控制，然后有8脚的tiny13A芯片可选（为了能集成到摩托车点火器中）。因为怕学单片机，就想请人把代码写好了写到芯片里发给我，工时费报价也不算贵，可后来我想了下，这程序不是写来了就能用上的，万一还要修改呢，这改来改去费用可不低啊。想想算了，反正10多年前就想自己学单片机，不如这次就圆了这个梦吧。于是前久从邮购部购买了马潮avr学习版，从当当网买来第二版书，因为看过电子版的，没有讲C语言语法，发现有点不适合我这种初学单片机的人，于是又购《入把手教你学单片机C程序设计（第2版）》和《手把手教你学AVR单片机C程序设计》，相互结合着学吧。初学问题真是多，这是发问贴：为什么这个状态机识别的if语句放到switch里就出错-出新问题
http://www.amobbs.com/thread-5575902-1-1.html
(出处: amoBBS 阿莫电子论坛)
可我发现这初学之路问题太多了，还有如直接开个关于这个单键密码锁的帖子，以日志的形式来记录制作过程，然后把碰到的问题写在这里，请大家帮忙解答！

学习平台：马潮avr学习板，软件是CVAVR＋AVRstudio

biying · 发表于 2014-4-11 10:33:12

本帖最后由 biying 于 2014-4-11 11:27 编辑

2014年4月11日遇到的问题，把void main(void)之前的一个空行删除了，仿真时默认的小箭头位置变了，这是正常时的截图

这是空行删除掉的，小箭头往下移了，如果是在之前添加代码的话，小箭头就上移了：

这到底是什么原因导致的？发现这个问题是因为我要往read_key_n()添加代码，导致仿真时不正确，然后我一步步还原就发现是添加删除oid main(void)之前的行，就会出这个问题。

这是出问题的工程压缩包

biying · 发表于 2014-4-11 11:06:03

本帖最后由 biying 于 2014-4-11 12:51 编辑

我新建了个工程，发现原来case后面的：被我识写成；这样都居然能编译通过，测试后没有之前的问题了，不过如果调出之前的工程来，就算把：改回来也不行，还是没有找到问题的原因

我把相关变量定义移到状态机里，就正常了。难道是变量的定义出问题？

biying · 发表于 2014-4-11 20:58:04

本帖最后由 biying 于 2014-4-11 21:41 编辑

今天下午还遇到一个问题，长按已经可以关门了，但是在识别第一位密码时，没有在不动按键2秒后识别密码，而是2秒内就动作了。后来查出是2秒定时器清零，我清除的只是2秒到的标志，真正的2秒计时清除没有打上，就是下图圈中的代码：

到现在，我的代码已经可以达到短按停止后，记录第一位密码的程度了，看上图，我短按了5次，在watch窗口里已经可以看到mima[0]=5了。

biying · 发表于 2014-4-12 02:39:41

新问题来了，第二位密码不能记录：

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
unsigned char mima[2],ysmima[2]={1,2},mimajishu,shucuo,i,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 2)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.7 // 按键输入口
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1"
yimiao_counter = 0;
yimiao_ok = 0;
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 200) // 按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
yimiao_ok = 1; //计时1秒后关门断开
}
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
break;
}
return key_return;
}
void main(void)
{
PORTA = 0x00; // 显示控制I/O端口初始化
DDRA = 0xFF;
PORTB = 0xFF;
DDRB = 0xFF;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[0] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<1; //PORTB = 0xFD; //执行开门，PB1拉低
status = 2;
}
}
break;
case 2:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[1] = mimajishu; //记录第二位密码
mimajishu =0;
for(i=0;i<2;i++) //密码对比识别
{
if (mima[i]==ysmima[i])
{
cnt++;
}
}
if (cnt==2){cnt=0;PORTB ^= 1<<2;status = 0;shucuo=0;} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 3;++shucuo;}
}
}
break;
case 3:
if(shucuo==3)
{
PORTB ^= 1<<3;
status = 0;
}
else status = 0;
break;
}
}
}

复制代码

第一位密码1已经识别，第二位没录入。全速仿真后我发现先按1和2，再按2和1就可以认为是密码输入对了，看来又出错了

biying · 发表于 2014-4-12 04:04:03

找到原因了，原来是很多应该清零的地方没有清零

while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[0] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<1; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
status = 2;
yimiao_counter = 0;
yimiao_ok = 0;
}
}
break;
case 2:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[1] = mimajishu; //记录第二位密码
mimajishu =0;
for(i=0;i<2;i++) //密码对比识别
{
if (mima[i]==ysmima[i])
{
cnt++;
}
}
if (cnt==2){cnt=0;PORTB ^= 1<<2;status = 0;shucuo=0;mima[1] = 0; mima[0] = 0;} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 3;++shucuo;cnt=0;mima[1] = 0; mima[0] = 0;} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
}
break;
case 3:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<3; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
}
}
}

复制代码

现在输入2位密码，先按1，隔1秒后再输入2就开门了。如果按第一位密码后，超过2秒不按，那就默认第位密码是0了，之后立即判断这两位密码是否正确，不正确就返回等待重新输入，输入3次密码不对就动作了。如果是多位密码，这个密码之间的间隔不太好掌握，打算加个灯来反馈。

biying · 发表于 2014-4-12 11:55:10

现在加入看门狗

void main(void)
{
PORTA = 0x00; // 显示控制I/O端口初始化
DDRA = 0xFF;
PORTB = 0xFF;
DDRB = 0xFF;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
//WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[0] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<1; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
status = 2;
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
}
}
break;
case 2:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (ermiao_ok)
{
mima[1] = mimajishu; //记录第二位密码
mimajishu =0;
for(i=0;i<2;i++) //密码对比识别
{
if (mima[i]==ysmima[i])
{
cnt++;
}
}
if (cnt==2){cnt=0;PORTB ^= 1<<2;status = 0;shucuo=0;mima[1] = 0; mima[0] = 0;} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 3;++shucuo;cnt=0;mima[1] = 0; mima[0] = 0;} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
}
break;
case 3:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<3; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
}
#asm("WDR")
}
}

复制代码

biying · 发表于 2014-4-12 11:56:13

怎么今天1楼就不能修改了？

biying · 发表于 2014-4-14 22:55:27

加入看门狗和掉电模式中断唤醒，INT0兼密码输入：

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
unsigned char mima[2],ysmima[2]={5,4},mimajishu,shucuo,i,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 2)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1"
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 200) // 按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
yimiao_ok = 1; //计时1秒后关门断开
}
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
break;
}
return key_return;
}
void main(void)
{
PORTA = 0x00; // 显示控制I/O端口初始化
DDRA = 0xFF;
PORTB = 0xFF;
DDRB = 0xFF;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
MCUCR = 0x60; // 睡眠使能，掉电模式
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[0] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<1; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
status = 2;
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
}
}
break;
case 2:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (ermiao_ok)
{
mima[1] = mimajishu; //记录第二位密码
mimajishu =0;
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
for(i=0;i<2;i++) //密码对比识别
{
if (mima[i]==ysmima[i])
{
cnt++;
}
}
if (cnt==2){cnt=0;PORTB ^= 1<<2;status = 0;shucuo=0;mima[1] = 0; mima[0] = 0;} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 3;++shucuo;cnt=0;mima[1] = 0; mima[0] = 0;} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
}
break;
case 3:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<3; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
}
if (simiao_ok) //4秒无动作后休眠
{
simiao_counter = 0;
simiao_ok = 0;
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<6; //休眠监测
WDTCR=0x18; //关看门狗
WDTCR=0x00;
//PORTB = 0xFF;
GICR = 0x40; //使能INT0中断
#asm("sleep")
PORTB ^= 1<<5; //唤醒后监测
}
#asm("WDR")
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
}

复制代码

下一步打算用两个IO口来接LED灯来显示兼密码输入和中断唤醒。

biying · 发表于 2014-4-14 22:56:38

以后再加入密码设置的话，可能TINY13Ａ怕是装不下了。

zyw19987 · 发表于 2014-4-15 06:50:49

biying 发表于 2014-4-14 22:56
以后再加入密码设置的话，可能TINY13Ａ怕是装不下了。

http://www.amobbs.com/forum.php? ... 0174&highlight=
哈哈，楼主还在研究这个啊?按我说的思路做?

biying · 发表于 2014-4-15 12:25:58

zyw19987 发表于 2014-4-15 06:50
http://www.amobbs.com/forum.php?mod=viewthread&tid=5570174&highlight=
哈哈，楼主还在研究这个啊?按 ...

谢谢你，我现在改来改去的，根据需要吧

biying · 发表于 2014-4-15 12:26:43

现在的问题是休眠后怎么电流还有7毫安左右呢？

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
unsigned char mima[2],ysmima[2]={5,4},mimajishu,shucuo,i,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 2)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1"
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 200) // 按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
yimiao_ok = 1; //计时1秒后关门断开
}
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
break;
}
return key_return;
}
void main(void)
{
//PORTA = 0x00; // 显示控制I/O端口初始化
// DDRA = 0xFF;
PORTB = 0xFF;
DDRB = 0xFF;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
PORTC=0x00;
DDRC=0x00;
PORTA=0x00;
DDRA=0x00;
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (yimiao_ok)
{
mima[0] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<1; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
status = 2;
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
}
}
break;
case 2:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
if (ermiao_ok)
{
mima[1] = mimajishu; //记录第二位密码
mimajishu =0;
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
for(i=0;i<2;i++) //密码对比识别
{
if (mima[i]==ysmima[i])
{
cnt++;
}
}
if (cnt==2){cnt=0;PORTB ^= 1<<2;status = 0;shucuo=0;mima[1] = 0; mima[0] = 0;} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 3;++shucuo;cnt=0;mima[1] = 0; mima[0] = 0;} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
}
break;
case 3:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<3; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
}
if (simiao_ok) //4秒无动作后休眠
{
simiao_counter = 0;
simiao_ok = 0;
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<6; //休眠监测
WDTCR=0x18; //关看门狗
WDTCR=0x00;
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
#asm("sleep") //休眠
PORTB ^= 1<<5; //唤醒后监测
}
#asm("WDR") //喂狗
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-15 12:27:19

而且如果是插在板上电流更高

zyw19987 · 发表于 2014-4-16 06:07:41

biying 发表于 2014-4-15 12:27
而且如果是插在板上电流更高

只靠CPU休眠是达不到你的要求的

biying · 发表于 2014-4-16 07:57:51

zyw19987 发表于 2014-4-16 06:07
只靠CPU休眠是达不到你的要求的

是啊，这个摩托车电压有14.4V，电动车有60V，如何解决这个单片机的供电和掉电模式后的供电是个问题，我测试了一下其它报警器供电电流，没报警的时候都还有7毫安呢，遥控接收电路要耗电情有可言，可我这个不需要它。还有按键开关线太长会不会产生干扰不得而知。

biying · 发表于 2014-4-16 08:09:40

刚才测试了一下，JTAG打开，4M片内，5V供电，工作电流4.5毫安，掉电模式1.9毫安，看来这个JTAG还真费电

1638574407 · 发表于 2014-4-16 09:59:13

好厉害！！！！！！！！！思路很好啊！！

biying · 发表于 2014-4-19 02:15:50

之前密码处理的方式，如果密码位数多的话，将导致代码容量高，于是我把密码输入部分作成一个函数来调用，有多少位密码都只调用同一个部分。可是代码容量还是达到了1020，如果加上密码设定部分，使用tiny13a可能无望了。

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
unsigned char mima[5],ysmima[5]={5,4,3,2,1},mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 2)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
}
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
else if (++key_time >= 100) // 长按2秒按键时间计数
{
key_state = key_state_4; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
}
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
yimiao_counter = 0;
yimiao_ok = 0;
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (yimiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
i=++i;
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;mima[1] = 0; mima[0] = 0;} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
}
if (simiao_ok) //4秒无动作后休眠
{
simiao_counter = 0;
simiao_ok = 0;
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-19 02:18:25

本帖最后由 biying 于 2014-4-19 03:09 编辑

看来还要再优化代码，我现在看到一个清零的那堆代码，好像可以做成函数来调用，到时加入设置密码时又能省下一部分容量。现在压缩到990

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
unsigned char mima[5],ysmima[5]={5,4,3,2,1},mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 2)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
qingling(); //清零
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
else if (++key_time >= 100) // 长按2秒按键时间计数
{
key_state = key_state_4; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
}
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (yimiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
//simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-19 05:42:05

为什么设定好第5位密码后就像休眠了呢？且设定的密码只能存2位（仿真看到的）

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
qingling(); //清零
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
else if (++key_time >= 100) // 长按2秒按键时间计数
{
key_state = key_state_4; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
}
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (yimiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //密码对比识别
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
if (read_key_n() == 3) //密码设置
{
status = 3;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 3:
if (read_key_driver() ==1 )
{
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //保存设置密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
simiao_ok=0;
}
status = 0;
qingling(); //清零
#asm("WDR") //喂狗
}
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
//simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-19 05:45:54

也不像是休眠，应该是全部灯灭了

biying · 发表于 2014-4-19 10:19:49

找到原因了，是EEPROM读写没有给足够的时间

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
qingling(); //清零
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
else if (++key_time >= 100) // 长按2秒按键时间计数
{
key_state = key_state_4; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
}
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (yimiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //密码对比识别
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
if (read_key_n() == 3) //密码设置
{
status = 3;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 3:
if (read_key_driver() ==1 )
{
PORTB = 0x00; //进入休眠前关所有灯
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //保存设置密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
simiao_ok=0;
delay_ms(10);
}
status = 0;
qingling(); //清零
#asm("WDR") //喂狗
}
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-19 10:41:50

为什么运行后设置好密码后不能识别呢？原来得重启才能生效，现在改动一下就能让设置的密码不用重启就能立即生效。仿真时eepromw数据会被全部置FF，这个要在哪里设置取消这个功能？

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status; // 时间计数单元，
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
qingling(); //清零
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
else if (++key_time >= 100) // 长按2秒按键时间计数
{
key_state = key_state_4; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
}
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (yimiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0xFF;
DDRD = 0x00; // PD7为输入方式
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //密码对比识别
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
if (read_key_n() == 3) //密码设置
{
status = 3;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 3:
if (read_key_driver() ==1 )
{
PORTB = 0x00; //密码进入记录阶段
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //保存设置密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
delay_ms(10);
}
status = 0;
qingling(); //清零
#asm("WDR") //喂狗
}
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-19 10:55:33

我找到了，原来要在这里设置JTAGICE调试选项，“Preserve EEPROM contents when reprogramming device”选框
该选框的值会改变目标芯片中“保护EEPROM熔丝位”的值，如果该选框被选中，那么在
重编程芯片或做芯片擦除时，目标芯片内EEPROM的数据就不会被清除。

biying · 发表于 2014-4-20 08:57:03

本帖最后由 biying 于 2014-4-21 01:13 编辑

现在加入单按键兼LED显示和休眠后唤醒，也就是在按键上并接一个LED灯，然后串接一个电阻后接到两个IO口上，实现多功能，闪灯程序通过设置闪灯标志和预设闪灯计数初值来实现快闪慢闪，从而表示不同的含义。

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status,shangdeng; // 时间计数单元，闪灯标志，闪灯时长
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
unsigned int shangdengtime;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
qingling(); //清零
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 输出"2"
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
else if (++key_time >= 100) // 长按2秒按键时间计数
{
key_state = key_state_4; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
}
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (yimiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdeng = 1; //并闪灯
shangdengtime = 54000; //设置闪灯时间
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
shangdeng = 1; //并闪灯
shangdengtime = 0; //设置长闪灯时间
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //密码对比识别
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为4s
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码处理
{
status = 1;
}
if (read_key_n() == 3) //密码设置
{
status = 3;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 3:
if (read_key_driver() ==1 )
{
PORTB = 0x00; //密码进入记录阶段
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //保存设置密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
delay_ms(10);
}
status = 0;
//qingling(); //清零
//#asm("WDR") //喂狗
}
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
if(shangdeng==1) //闪灯
{
PORTD |=( 1<<7); //PD7输出高
PORTD &=~( 1<<2); //INT0拉低
DDRD = 0xFF;
if (++shangdengtime >= 60000) //按键闪灯指示程序
{
shangdeng = 0;
shangdengtime = 0;
}
}
PORTD = 0x7F; //恢复端口检测
DDRD = 0x80; // PD7为输出方式，默认输出低电平
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

奇怪，为什么把108行里“else if (++key_time >= 100) // 长按2秒按键时间计数”的100改成255后，就不能进入密码设置？
也就是不能执行234行的“status = 3; ”，仿真时，应该看到key_return = 3了呢，可为什么还是不能第执行234行呢？一旦把255改成其它就可以包括254。

biying · 发表于 2014-4-20 09:45:43

这是按键电路图，左边是之前的，右边是改进的，因为按键检测和闪灯是实时的，所以这样改进，按键检测的时候也不影响闪灯。

biying · 发表于 2014-4-20 09:52:00

不过现在的程序怎么会实现INT0唤醒了呢？休眠的时候PD.2应该被拉低才能唤醒，可是我看程序是把PD.7设置为输入带上拉呢！

biying · 发表于 2014-4-21 04:24:24

现在加入设置新密码要先验证老密码，下一步应该要加入如何恢复原始密码了。

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status,shangdeng; // 时间计数单元，闪灯标志，闪灯时长
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
unsigned int shangdengtime;
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
shangdeng = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 65000; //设置闪灯时间
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
shangdeng = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 54000; //设置闪灯时间
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
key_return = 2; // 长按超过1秒后输出"2" ，
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
shangdeng = 1; //开长闪灯
shangdengtime = 30000; //设置长闪灯时间
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdeng = 1; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 60000; //设置闪灯时间
}
}
break;
case 1:
if (i == 5) //密码识别位数确认
{
i=0;
aj_state = 0;
key_return = 1;
shangdeng = 1; //开长闪灯表示密码输入完成
shangdengtime = 30000; //设置长闪灯时间
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为16.3ms
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码输入处理部分
{
status = 1;
}
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 11;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 11: //密码设置第一步：输入原密码，正确后才能设置新密码
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 12;shucuo=0;shangdeng = 1;shangdengtime = 0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 0;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 14;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 15;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
PORTB = 0x00; //全亮灯密码进入记录阶段
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 12;
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
if(shangdeng==1) //闪灯
{
qingling(); //清零
PORTD |=( 1<<7); //PD7输出高
PORTD &=~( 1<<2); //INT0拉低
DDRD = 0xFF;
if (++shangdengtime >= 65530) //按键闪灯指示程序
{
shangdeng = 0;
shangdengtime = 0;
}
}
PORTD = 0x7F; //恢复端口检测
DDRD = 0x80; // PD7为输出方式，默认输出低电平
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-21 04:27:26

本帖最后由 biying 于 2014-4-21 04:28 编辑

还要加LED灯快速闪几次，方便表达某些意义。这路越走，离tiny13a越远了。

biying · 发表于 2014-4-22 02:13:58

现在加入闪灯程序和按一下PD.7恢复初始密码

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status,shangdengcishu; // 时间计数单元，闪灯时长、次数
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
unsigned int shangdengtime;
unsigned char huifu[5]={1,2,3,4,5};
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
void shangdeng(void) //闪灯
{
static unsigned char status;
static unsigned int i;
if(shangdengcishu >0) //闪灯次数类似倒计时程序
{
switch (status)
{
case 0:
qingling(); //清零
PORTD |=( 1<<7); //PD7输出高
PORTD &=~( 1<<2); //INT0拉低
DDRD = 0xFF;
if (++i >= shangdengtime) //按键闪灯指示程序
{
status=1;
i=0;
}
break;
case 1:
if (++i >= shangdengtime+10000) //按键闪灯指示程序
{
i=0;
status=0;
--shangdengcishu ;
}
break;
}
}
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
shangdengcishu = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 2500; //设置闪灯时间
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
shangdengcishu = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 11000; //设置闪灯时间
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
key_return = 2; // 长按超过1秒后输出"2" ，
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
shangdengcishu = 1; //开长闪灯
shangdengtime = 50000; //设置长闪灯时间
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdengcishu = i; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 1500; //设置闪灯时间
}
}
break;
case 1:
if (i == 5) //密码识别位数确认，闪2次标示密码输完
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为16.3ms
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码输入处理部分
{
status = 1;
}
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 11;
}
PORTD |=( 1<<7); //PD7输出高
DDRD &=~( 1<<7); //PD7设置成输入
if(PIND.7 == 0) //若PD7拉低就把密码恢复出厂设置
{
shangdengcishu = 5; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 1500; //设置闪灯时间
//unsigned char mima[5]={1,2,3,4,5};
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = huifu[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = huifu[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
}
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 11: //密码设置第一步：输入原密码，正确后闪烁3次，然后开始设置新密码
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 12;shucuo=0;shangdengcishu = 3;shangdengtime = 50000;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 0;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 14;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 15;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
PORTB = 0x00; //全亮灯密码进入记录阶段
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 12;
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯
PORTD = 0x7F; //恢复端口检测
DDRD = 0x80; // PD7为输出方式，默认输出低电平
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-22 08:54:36

之前快速按键，闪灯会眼不上节奏，这是因为关灯时间不可调，是10000，现在把它设成一个变量，对于只亮一次的就设为0，闪多次的就设回来10000。

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status,shangdengcishu; // 时间计数单元，闪灯时长、次数
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok;
unsigned int shangdengtime,guangdengtime;
unsigned char huifu[5]={1,2,3,4,5};
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
void shangdeng(void) //闪灯
{
static unsigned char status;
static unsigned int i;
if(shangdengcishu >0) //闪灯次数类似倒计时程序
{
switch (status)
{
case 0:
qingling(); //清零
PORTD |=( 1<<7); //PD7输出高
PORTD &=~( 1<<2); //INT0拉低
DDRD = 0xFF;
if (++i >= shangdengtime) //按键闪灯指示程序
{
status=1;
i=0;
}
break;
case 1:
if (++i >= shangdengtime+guangdengtime) //按键闪灯指示程序
{
i=0;
status=0;
--shangdengcishu ;
}
break;
}
}
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
shangdengcishu = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 1500; //设置闪灯时间
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
shangdengcishu = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 11000; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
key_return = 2; // 长按超过1秒后输出"2" ，
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
shangdengcishu = 1; //开长闪灯
shangdengtime = 50000; //设置长闪灯时间
guangdengtime = 0; //设置关灯时间
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdengcishu = i; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 1500; //设置闪灯时间
guangdengtime = 10000; //设置关灯时间
}
}
break;
case 1:
if (i == 5) //密码识别位数确认，闪2次标示密码输完
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为16.3ms
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码输入处理部分
{
status = 1;
}
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 11;
}
PORTD |=( 1<<7); //PD7输出高
DDRD &=~( 1<<7); //PD7设置成输入
if(PIND.7 == 0) //若PD7拉低就把密码恢复出厂设置
{
shangdengcishu = 5; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 1500; //设置闪灯时间
guangdengtime = 10000; //设置关灯时间
//unsigned char mima[5]={1,2,3,4,5};
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = huifu[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = huifu[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
}
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 11: //密码设置第一步：输入原密码，正确后闪烁3次，然后开始设置新密码
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 12;shucuo=0;shangdengcishu = 3;shangdengtime = 50000;guangdengtime = 10000;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 0;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 14;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 15;shucuo=0;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
PORTB = 0x00; //全亮灯密码进入记录阶段
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 12;
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
DDRB = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯
PORTD = 0x7F; //恢复端口检测
DDRD = 0x80; // PD7为输出方式，默认输出低电平
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-22 10:54:16

本帖最后由 biying 于 2014-4-22 12:15 编辑

奇怪，为什么开机（包括开机没动休眠后）第一次快速的按动开关，LED灯可以跟随闪动，等再数第二位密码的时候，如果按得快，LED灯闪动就跟不上了呢？到底是程序拖满了它？闪动跟不上，但是实际按动的次数是对的。如何把192行去掉，就正常了，但是不能单独设关灯时间了，程序里其它地方只要有更改过guangdengtime 值的地方，就会出现单击的时候不跟随，也就是单击里的guangdengtime = 0; //设置关灯时间不生效，

biying · 发表于 2014-4-22 12:17:11

找到原因了，原来是119行里漏输一行：guangdengtime = 0; //设置关灯时间

biying · 发表于 2014-4-22 13:00:47

现在遇到一个问题：在按键灯长亮的时候，如果我此时短按输入密码，那么第一个按键指示灯看起来没反应，因为此时灯是长亮的，程序应该执行先关长亮灯，延时一会，然后再调用短按闪灯

biying · 发表于 2014-4-23 18:40:11

奇怪，怎么修改这里后，按键就没有反应了呢？只有把PD.2直接对地才行，改回程序后也不行，换芯片也不行，真的是见鬼了。

if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
//PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0x00;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}

复制代码

biying · 发表于 2014-4-24 10:10:09

解决，把G区接PD.2的按键取了就正常了，因为那里是上拉5V的，我记着是没动过那里呢，看来以后出问题得拍照电路板先。

biying · 发表于 2014-4-25 03:15:16

本帖最后由 biying 于 2014-4-25 03:26 编辑

LED闪灯程序改进了，此时长亮灯时短按可以看到灯闪了，编得真是费劲啊
同时把恢复初始密码的方法改为上电拉低后恢复

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status,shangdengcishu; // 时间计数单元，闪灯次数
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok,kaidengduibi; //第一次开关未完成时，第二次开灯指令的识别
unsigned int shangdengtime,guangdengtime; //闪灯开的时间，闪灯关的时间
unsigned char huifu[5]={1,2,3,4,5}; //初始密码
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
void shangdeng(void) //闪灯
{
static unsigned char status=1,kaidengbiaozhi;
static unsigned int i,j,h;
if(shangdengcishu >0) //闪灯次数类似倒计时程序
{
if(kaidengduibi==1) //开灯比对,有新的开灯指令时为1
{
status=0;
}
switch (status)
{
case 0:
kaidengduibi=0; //开灯对比，对比结束
if(kaidengbiaozhi == 1) //上一次开灯程序未完成标志
{
if (++h >= 3000-j) //按键关灯时间，实现第一次正在开灯，或者正在关灯时，若第二次开灯指令就来了，就先执行关灯
{
j=0;
h=0;
status=1;
i=0;
}
}
else status=1;
break;
case 1:
qingling(); //清零
PORTD |=( 1<<7); //PD7输出高
PORTD &=~( 1<<2); //INT0拉低
DDRD = 0xFF;
kaidengbiaozhi=1; //开灯标志，表示开灯任务开始
PORTD = 0x7F; //恢复端口检测
DDRD = 0x80; // PD7为输出方式，默认输出低电平
if (++i >= shangdengtime) //按键开灯时间
{
status=2;
i=0;
}
break;
case 2:
if (++j >= guangdengtime) //按键关灯时间
{
j=0;
status=0;
--shangdengcishu ;
// kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
if(i==3000) //灭灯时间达到设定值时，把开关标志清零，也就是可以再次接受新的开灯指令了，这样再开灯时就能及时看到亮灯
{
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
break;
}
}
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
shangdengcishu = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 1500; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
shangdengcishu = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 1500; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
key_return = 2; // 长按超过1秒后输出"2" ，
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
shangdengcishu = 3; //开长闪灯
shangdengtime = 65000; //设置长闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdengcishu = i; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 3000; //设置闪灯时间
guangdengtime = 8000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
}
break;
case 1:
if (i == 5) //密码识别位数确认，闪2次标示密码输完
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
delay_ms(100);
/*上电恢复初始密码*/
PORTD |=( 1<<7); //PD7输出高
DDRD &=~( 1<<7); //PD7设置成输入
if(PIND.7 == 0) //若PD7拉低就把密码恢复出厂设置
{
shangdengcishu = 5; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 15000; //设置闪灯时间
guangdengtime = 10000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = huifu[j]; //恢复默认密码
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = huifu[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
delay_ms(5000);
}
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为16.3ms
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码输入处理部分
{
status = 1;
}
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 11;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;shangdengcishu = 1;shangdengtime = 50000;guangdengtime = 0;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 11: //密码设置第一步：输入原密码，正确后闪烁3次，然后开始设置新密码
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 12;shucuo=0;shangdengcishu = 1;shangdengtime = 50000;guangdengtime = 0;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 0;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 14;shucuo=0;shangdengcishu = 1;shangdengtime = 50000;guangdengtime = 0;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 15;shucuo=0;shangdengcishu = 3;shangdengtime = 50000;guangdengtime = 10000;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
PORTB = 0x00; //全亮灯密码进入记录阶段
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 12;
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0x00;
PORTC=0xFF;
DDRC=0x00;
//PORTD = 0xFF;
//DDRD = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
//PORTD = 0x7F;
//DDRD = 0x80; // PD7为输出方式，默认输出低电平
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-25 08:55:42

仿真时发现短按闪灯有延迟，再看代码，发现109行和111行有错误，改为以下后正常

/*********************************************
File name : demo_9_2.c
Chip type : ATmega16
Program type : Application
Clock frequency : 4.000000 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*********************************************/
#include <mega16.h>
#include<delay.h>
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt,cabz; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char simiao_counter,ermiao_counter,yimiao_counter,key_stime_counter,status,shangdengcishu; // 时间计数单元，闪灯次数
unsigned char simiao_ok,ermiao_ok,yimiao_ok,key_stime_ok,kaidengduibi; //第一次开关未完成时，第二次开灯指令的识别
unsigned int shangdengtime,guangdengtime; //闪灯开的时间，闪灯关的时间
unsigned char huifu[5]={1,2,3,4,5}; //初始密码
// Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++simiao_counter >= 4)
{
simiao_counter = 0;
simiao_ok = 1; // 4s到
}
}
}
}
}
#define key_input PIND.2 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
simiao_counter = 0;
simiao_ok = 0;
}
void shangdeng(void) //闪灯
{
static unsigned char status=1,kaidengbiaozhi;
static unsigned int i,j,h;
if(shangdengcishu >0) //闪灯次数类似倒计时程序
{
if(kaidengduibi==1) //开灯比对,有新的开灯指令时为1
{
status=0;
}
switch (status)
{
case 0:
kaidengduibi=0; //开灯对比，对比结束
if(kaidengbiaozhi == 1) //上一次开灯程序未完成标志
{
if (++h >= 3000-j) //按键关灯时间，实现第一次正在开灯，或者正在关灯时，若第二次开灯指令就来了，就先执行关灯
{
j=0;
h=0;
status=1;
i=0;
}
}
else status=1;
break;
case 1:
qingling(); //清零
PORTD |=( 1<<7); //PD7输出高
PORTD &=~( 1<<2); //INT0拉低
DDRD = 0xFF;
kaidengbiaozhi=1; //开灯标志，表示开灯任务开始
PORTD = 0x7F; //恢复端口检测
DDRD = 0x80; // PD7为输出方式，默认输出低电平
if (++i >= shangdengtime) //按键开灯时间
{
status=2;
i=0;
}
break;
case 2:
if (++j >= guangdengtime) //按键关灯时间
{
j=0;
status=0;
--shangdengcishu ;
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
if(j>=3000) //灭灯时间达到设定值时，把开关标志清零，也就是可以再次接受新的开灯指令了，这样再开灯时就能及时看到亮灯
{
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
break;
}
}
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
shangdengcishu = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 1500; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
shangdengcishu = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 1500; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
cabz = 1; //长按标志
PORTB ^= 1<<0; //PORTB = 0xFE; //PB0拉低，关门
key_return = 2; // 长按超过1秒后输出"2" ，
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
PORTB ^= 1<<1;
shangdengcishu = 3; //开长闪灯
shangdengtime = 65000; //设置长闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<2; //PORTB = 0xFD; //执行开门，PB1拉低观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdengcishu = i; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 3000; //设置闪灯时间
guangdengtime = 8000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
}
break;
case 1:
if (i == 5) //密码识别位数确认，闪2次标示密码输完
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0xFF;
PORTC=0xFF;
DDRC=0x00;
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
delay_ms(100);
/*上电恢复初始密码*/
PORTD |=( 1<<7); //PD7输出高
DDRD &=~( 1<<7); //PD7设置成输入
if(PIND.7 == 0) //若PD7拉低就把密码恢复出厂设置
{
shangdengcishu = 5; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 15000; //设置闪灯时间
guangdengtime = 10000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = huifu[j]; //恢复默认密码
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = huifu[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
delay_ms(5000);
}
PORTD = 0x7F;
DDRD = 0x80; // PD7为输出方式，默认输出低电平
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
ADCSRA=0x00;
TWCR=0x00;
SPCR=0x00;
ACSR=0x80;
SFIOR=0x00;
UCSRB=0x00;
ACSR=(1<<ACD);
// T/C0 初始化
TCCR0 = 0x0B; // 内部时钟，64分频（4M/64=62.5KHz），CTC模式
TCNT0 = 0x00;
OCR0 = 0x7C; // OCR0 = 0x7C(124),(124+1)/62.5=2ms
TIMSK = 0x02; // 允许T/C0比较匹配中断
//mima[1] = 0; mima[0] = 0; // 设输入密码初值00
#asm("cli")
#asm("WDR")
WDTCR=0x08; //看门狗约为16.3ms
WDTCR=0x28;
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
if (read_key_n() == 1) //不断扫描按键，如果有长按就关门，若有短按就装到密码输入处理部分
{
status = 1;
}
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 11;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 0;shucuo=0;shangdengcishu = 1;shangdengtime = 50000;guangdengtime = 0;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
if(shucuo==3) //输错3次就执行某行动
{
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 11: //密码设置第一步：输入原密码，正确后闪烁3次，然后开始设置新密码
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 12;shucuo=0;shangdengcishu = 1;shangdengtime = 50000;guangdengtime = 0;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 0;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 14;shucuo=0;shangdengcishu = 1;shangdengtime = 50000;guangdengtime = 0;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5){cnt=0;PORTB ^= 1<<3;status = 15;shucuo=0;shangdengcishu = 3;shangdengtime = 50000;guangdengtime = 10000;kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
PORTB = 0x00; //全亮灯密码进入记录阶段
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EEDR = mima[j];
EECR |=(1 <<EEMWE);
EECR |=(1 <<EEWE);
ysmima[j] = mima[j]; //密码立即生效
simiao_ok=0;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEWE));
EEAR = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<4; //某行动
status = 0;
}
else status = 12;
break;
}
if (simiao_ok) //4秒无动作后休眠
{
qingling(); //清零
TIMSK = 0x00; //关T/C0比较匹配中断
PORTB ^= 1<<5; //休眠监测
//WDTCR=0x18; //关看门狗
//WDTCR=0x00;
WDTCR=(1<<WDTOE)|(1<<WDE);
WDTCR=(0<<WDE);
PORTB = 0xFF; //进入休眠前关所有灯
GICR = 0x40; //使能INT0中断
MCUCR = 0x60; // 睡眠使能，掉电模式
//MCUCSR=(1<<JTD);
//MCUCSR=(1<<JTD);
PORTA=0xFF;
DDRA=0x00;
PORTB = 0xFF;
DDRB = 0x00;
PORTC=0xFF;
DDRC=0x00;
//PORTD = 0xFF;
//DDRD = 0x00;
#asm("sleep") //休眠
PORTB ^= 1<<6; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯
}
}
interrupt[EXT_INT0]void ext_int0_isr(void)
{
PORTB = 0xFF;
DDRB = 0xFF;
//PORTD = 0x7F;
//DDRD = 0x80; // PD7为输出方式，默认输出低电平
TIMSK = 0x02; // 允许T/C0比较匹配中断
simiao_counter=0;
PORTB ^= 1<<7; //中断唤醒监测
GICR = 0x00; //禁用INT0中断
WDTCR=0x08; //开看门狗约为4s
WDTCR=0x28;
MCUCR = 0x00; // 禁止睡眠使能，在需要休眠时再打开0
}

复制代码

biying · 发表于 2014-4-28 16:14:43

发现一个现像：这种是能通过编译的/*......*/，但这种就不行/*.../*......*/...*/，也就是注释里再注释就不行了

biying · 发表于 2014-5-2 03:19:30

从官网手册中拷贝过来的代码编译出错

在查了2个多小时后，终于发现是手册里少了个分号

说明我还是不够仔细。

biying · 发表于 2014-5-4 10:05:05

为什么这样可以休眠后唤醒：

if (ershimiao_ok) //20秒无动作后休眠
{
shucuo=0; //2次输错密码，若没有再输入密码，进入休眠就清除记录
qingling(); //清零
//PORTB = 11100110; //11100110进入休眠前关所有灯
//DDRB = 00100001; //00100001，PB.0和5配置为输出，其它位为输入
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
TIMSK = 0x00; //关闭T/C0比较匹配中断
/*关闭看门狗省电*/
//#asm("cli") //关闭全局中断
#asm("WDR") //喂狗
//MCUSR = 0x00;
//WDTCR |= (1<<WDCE) | (1<<WDE);
//WDTCR = 0x00;
MCUSR &= ~(1<<WDRF);
WDTCR |= (1<<WDCE) | (1<<WDE);
WDTCR &= ~(1<<WDE);
#asm("sei") // 开放全局中断
/*使能INT0中断*/
GIMSK=0x40;
MCUCR=0x00;
GIFR=0x40;
MCUCR |= (1<<SM1) | (0<<SM0); // 掉电模式
MCUCR |= (1<<SE); //睡眠使能
#asm("sleep") //休眠
PORTB ^= 1<<5; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯

复制代码

但下面的这种就不能呢都是PB0输出低，PB1为输入上拉呢
if (ershimiao_ok)       //20秒无动作后休眠
      {
      shucuo=0;  //2次输错密码，若没有再输入密码，进入休眠就清除记录
      qingling(); //清零
      PORTB = 11100110; //11100110进入休眠前关所有灯
      DDRB = 00100001;  //00100001，PB.0和5配置为输出，其它位为输入
      //PORTB |=( 1<<1); //置位
      //PORTB &=~( 1<<0);  //清零
      // DDRB = 0x39;
      TIMSK = 0x00; //关闭T/C0比较匹配中断
      /*关闭看门狗省电*/
      //#asm("cli") //关闭全局中断
      #asm("WDR") //喂狗
      //MCUSR = 0x00;
      //WDTCR |= (1<<WDCE) | (1<<WDE);
      //WDTCR = 0x00;
      MCUSR &= ~(1<<WDRF);
      WDTCR |= (1<<WDCE) | (1<<WDE);
      WDTCR &= ~(1<<WDE);
      #asm("sei")  // 开放全局中断
      /*使能INT0中断*/
      GIMSK=0x40;
      MCUCR=0x00;
      GIFR=0x40;
      MCUCR |= (1<<SM1) | (0<<SM0);  // 掉电模式
      MCUCR |= (1<<SE); //睡眠使能
      #asm("sleep")    //休眠
      PORTB ^= 1<<5;    //唤醒后监测
      }
      #asm("WDR") //喂狗
      shangdeng(); //扫描闪灯

biying · 发表于 2014-5-4 10:09:21

这是完整代码，真的是奇怪

#include <tiny85.h>
#include<delay.h>
// Declare your global variables here
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char ershimiao_counter,ermiao_counter,shucuo_counter,yimiao_counter,key_stime_counter,status,shangdengcishu; // 时间计数单元，闪灯次数
unsigned char ershimiao_ok,shucuo_ok,ermiao_ok,yimiao_ok,key_stime_ok,kaidengduibi; //第一次开关未完成时，第二次开灯指令的识别
unsigned int shangdengtime,guangdengtime; //闪灯开的时间，闪灯关的时间
unsigned char huifu[5]={1,2,3,4,5}; //初始密码
// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
TIMSK=0x10; // 允许T/C0比较匹配中断
PORTB ^= 1<<5; //中断唤醒监测
GIMSK=0x00; //禁用INT0中断，等合适的时候再打开
//GICR = 0x00; //禁用INT0中断
WDTCR=0x18; //开看门狗约为16ms
WDTCR=0x08;
MCUCR &=~(1<<SE); // 禁止睡眠使能，在需要休眠时再打开0
}
// Timer 0 output compare A interrupt service routine ， Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMPA] void timer0_compa_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++ershimiao_counter >= 15)
{
ershimiao_counter = 0;
ershimiao_ok = 1; // 30s到
if (++shucuo_counter >= 10)
{
shucuo_counter = 0;
shucuo_ok = 1; // 300s到
}
}
}
}
}
}
#define key_input PINB.1 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
ershimiao_counter = 0;
ershimiao_ok = 0;
shucuo_counter = 0;
shucuo_ok = 0; // 300s到
}
void shangdeng(void) //闪灯
{
static unsigned char status=1,kaidengbiaozhi;
static unsigned int i,j,h;
if(shangdengcishu >0) //闪灯次数类似倒计时程序
{
if(kaidengduibi==1) //开灯比对,有新的开灯指令时为1
{
status=0;
}
switch (status)
{
case 0:
kaidengduibi=0; //开灯对比，对比结束
if(kaidengbiaozhi == 1) //上一次开灯程序未完成标志
{
if (++h >= 3000-j) //按键关灯时间，实现第一次正在开灯，或者正在关灯时，若第二次开灯指令就来了，就先执行关灯
{
j=0;
h=0;
status=1;
i=0;
}
}
else status=1;
break;
case 1:
PORTB |=( 1<<0); //PD7输出高
PORTB &=~( 1<<1); //INT0拉低
DDRB = 0x3B;
qingling(); //清零
kaidengbiaozhi=1; //开灯标志，表示开灯任务开始
if (++i >= shangdengtime) //按键开灯时间
{
status=2;
i=0;
}
break;
case 2:
if (++j >= guangdengtime) //按键关灯时间
{
j=0;
status=0;
--shangdengcishu ;
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
if(j>=3000) //灭灯时间达到设定值时，把开关标志清零，也就是可以再次接受新的开灯指令了，这样再开灯时就能及时看到亮灯
{
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
break;
}
}
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
//PORTB=0x3A;
//DDRB=0x39;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
key_time = 0;
shangdengcishu = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 3000; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 长按超过1秒后输出"2" ，
shangdengcishu = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 60000; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
key_time = 0; // 清按键计数器
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
shangdengcishu = 3; //开长闪灯
shangdengtime = 65000; //设置长闪灯时间
guangdengtime = 10000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<5; //观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdengcishu = i; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 3000; //设置闪灯时间
guangdengtime = 17000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
}
break;
case 1:
if (i == 5) //密码识别位数确认，闪2次标示密码输完
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
// Declare your local variables here
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
// Input/Output Ports initialization
// Port B initialization
// Func5=In Func4=In Func3=In Func2=In Func1=In Func0=Out
// State5=T State4=T State3=T State2=T State1=T State0=0
//PORTB = 0xE6; //11100110
//DDRB = 0x39; //00100001，PB.0和5配置为输出，其它位为输入
PORTB=0x3A;
DDRB=0x39;
delay_ms(100);
/*上电恢复初始密码*/
PORTB |=( 1<<0); //PD7输出高
DDRB &=~( 1<<0); //PD7设置成输入
if(PINB.0 == 0) //若PD7拉低就把密码恢复出厂设置
{
shangdengcishu = 5; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 15000; //设置闪灯时间
guangdengtime = 10000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEPE));
EECR = (0<<EEPM1)|(0<<EEPM0);
EEARL = j+10;
EEDR = huifu[j]; //恢复默认密码
EECR |=(1 <<EEMPE);
EECR |=(1 <<EEPE);
ysmima[j] = huifu[j]; //密码立即生效
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
//delay_ms(5000);
}
//while(PIND.7 == 0) {;}
//PORTB = 0xE6; //11100110
//DDRB = 0x39; //00100001，PB.0和5配置为输出，其它位为输入 // PD7为输出方式，默认输出低电平
PORTB=0x3A;
DDRB=0x39;
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEPE));
EEARL = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 125.000 kHz
// Mode: CTC top=OCR0A
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x02;
TCCR0B=0x03;
TCNT0=0x00;
OCR0A=0xF9;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFF
// OC1A output: Disconnected
// OC1B output: Disconnected
// Timer1 Overflow Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
PLLCSR=0x00;
TCCR1=0x00;
GTCCR=0x00;
TCNT1=0x00;
OCR1A=0x00;
OCR1B=0x00;
OCR1C=0x00;
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Low level
// Interrupt on any change on pins PCINT0-5: Off
GIMSK=0x00; //禁用INT0中断，等合适的时候再打开
MCUCR=0x00;
GIFR=0x40;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x10;
// Universal Serial Interface initialization
// Mode: Disabled
// Clock source: Register & Counter=no clk.
// USI Counter Overflow Interrupt: Off
USICR=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
ACSR=0x80;
ADCSRB=0x00;
DIDR0=0x00;
// ADC initialization
// ADC disabled
ADCSRA=0x00;
// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/2k
// Watchdog Timer interrupt: Off
#pragma optsize-
#asm("wdr")
WDTCR=0x18;
WDTCR=0x08;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
// Global enable interrupts
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
switch(read_key_n())
{
case 0:
status = 0;
break;
case 1:
status = 1;
break;
case 2:
PORTB &= ~(1<<3);
PORTB |= (1<<4); //关门
DDRB = 0x39;
break;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5)
{
cnt=0;
//PORTB ^= 1<<3;
status = 3;
shucuo=0;
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/ //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
PORTB &=~(1<<5);
PORTB &=~(1<<4);
PORTB |=(1<<3); //开门
DDRB = 0x39;
}
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
while(shucuo==3) //输错3次就锁死300秒
{
#asm("WDR") //喂狗
if(shucuo_ok)
{
qingling(); //清零
status = 0;
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;
}
}
status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 3:
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 12;
}
else if (ermiao_ok) {status = 0;}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5)
{
cnt=0;
//PORTB ^= 1<<3;
status = 14;
shucuo=0;
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;
//mima[1] = 0; mima[0] = 0;
} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5)
{
cnt=0;
PORTB ^= 1<<5; //观察
status = 15;
shucuo=0;
shangdengcishu = 3;
shangdengtime = 50000;
guangdengtime = 10000;
kaidengduibi=1;
//mima[1] = 0; mima[0] = 0;
} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEPE));
EECR = (0<<EEPM1)|(0<<EEPM0);
EEARL = j+10;
EEDR = mima[j];
EECR |=(1 <<EEPM1);
EECR |=(1 <<EEPM0);
ysmima[j] = mima[j]; //密码立即生效
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEPE));
EEARL = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<5; //某行动
status = 0;
}
else status = 12;
break;
}
if (ershimiao_ok) //20秒无动作后休眠
{
shucuo=0; //2次输错密码，若没有再输入密码，进入休眠就清除记录
qingling(); //清零
//PORTB = 11100110; //11100110进入休眠前关所有灯
//DDRB = 00100001; //00100001，PB.0和5配置为输出，其它位为输入
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
TIMSK = 0x00; //关闭T/C0比较匹配中断
/*关闭看门狗省电*/
//#asm("cli") //关闭全局中断
#asm("WDR") //喂狗
//MCUSR = 0x00;
//WDTCR |= (1<<WDCE) | (1<<WDE);
//WDTCR = 0x00;
MCUSR &= ~(1<<WDRF);
WDTCR |= (1<<WDCE) | (1<<WDE);
WDTCR &= ~(1<<WDE);
#asm("sei") // 开放全局中断
/*使能INT0中断*/
GIMSK=0x40;
MCUCR=0x00;
GIFR=0x40;
MCUCR |= (1<<SM1) | (0<<SM0); // 掉电模式
MCUCR |= (1<<SE); //睡眠使能
#asm("sleep") //休眠
PORTB ^= 1<<5; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯
}
}
#include <tiny85.h>
#include<delay.h>
// Declare your global variables here
unsigned char mima[5],ysmima[5],mimajishu,shucuo,j,cnt; //密码计数，录入密码数组，原始密码数组，长按标志 // 2位密码计数单元
unsigned char ershimiao_counter,ermiao_counter,shucuo_counter,yimiao_counter,key_stime_counter,status,shangdengcishu; // 时间计数单元，闪灯次数
unsigned char ershimiao_ok,shucuo_ok,ermiao_ok,yimiao_ok,key_stime_ok,kaidengduibi; //第一次开关未完成时，第二次开灯指令的识别
unsigned int shangdengtime,guangdengtime; //闪灯开的时间，闪灯关的时间
unsigned char huifu[5]={1,2,3,4,5}; //初始密码
// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
TIMSK=0x10; // 允许T/C0比较匹配中断
PORTB ^= 1<<5; //中断唤醒监测
GIMSK=0x00; //禁用INT0中断，等合适的时候再打开
//GICR = 0x00; //禁用INT0中断
WDTCR=0x18; //开看门狗约为16ms
WDTCR=0x08;
MCUCR &=~(1<<SE); // 禁止睡眠使能，在需要休眠时再打开0
}
// Timer 0 output compare A interrupt service routine ， Timer 0 比较匹配中断服务，2ms定时
interrupt [TIM0_COMPA] void timer0_compa_isr(void)
{
if (++key_stime_counter >=5)
{
key_stime_counter = 0;
key_stime_ok = 1; // 10ms到
if (++yimiao_counter >= 100)
{
yimiao_counter = 0;
yimiao_ok = 1; // 1s到
if (++ermiao_counter >= 2)
{
ermiao_counter = 0;
ermiao_ok = 1; // 2s到
if (++ershimiao_counter >= 15)
{
ershimiao_counter = 0;
ershimiao_ok = 1; // 30s到
if (++shucuo_counter >= 10)
{
shucuo_counter = 0;
shucuo_ok = 1; // 300s到
}
}
}
}
}
}
#define key_input PINB.1 // 按键输入口兼INTO中断唤醒
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_state_4 4
void qingling(void) //清零
{
yimiao_counter = 0; //因为是最后一次按键清零后过了1秒，才开始第一位密码识别的，不清零的话后面第一个10ms过后就会把第二位密码记上了，
yimiao_ok = 0; //这会让你没有机会输入第二次密码
ermiao_counter = 0;
ermiao_ok = 0;
ershimiao_counter = 0;
ershimiao_ok = 0;
shucuo_counter = 0;
shucuo_ok = 0; // 300s到
}
void shangdeng(void) //闪灯
{
static unsigned char status=1,kaidengbiaozhi;
static unsigned int i,j,h;
if(shangdengcishu >0) //闪灯次数类似倒计时程序
{
if(kaidengduibi==1) //开灯比对,有新的开灯指令时为1
{
status=0;
}
switch (status)
{
case 0:
kaidengduibi=0; //开灯对比，对比结束
if(kaidengbiaozhi == 1) //上一次开灯程序未完成标志
{
if (++h >= 3000-j) //按键关灯时间，实现第一次正在开灯，或者正在关灯时，若第二次开灯指令就来了，就先执行关灯
{
j=0;
h=0;
status=1;
i=0;
}
}
else status=1;
break;
case 1:
PORTB |=( 1<<0); //PD7输出高
PORTB &=~( 1<<1); //INT0拉低
DDRB = 0x3B;
qingling(); //清零
kaidengbiaozhi=1; //开灯标志，表示开灯任务开始
if (++i >= shangdengtime) //按键开灯时间
{
status=2;
i=0;
}
break;
case 2:
if (++j >= guangdengtime) //按键关灯时间
{
j=0;
status=0;
--shangdengcishu ;
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
if(j>=3000) //灭灯时间达到设定值时，把开关标志清零，也就是可以再次接受新的开灯指令了，这样再开灯时就能及时看到亮灯
{
kaidengbiaozhi=0; //开灯标志，标示开灯任务结束,准备好第二次开关了
}
break;
}
}
}
unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
//PORTB=0x3A;
//DDRB=0x39;
key_press = key_input; // 读按键I/O电平
switch (key_state)
{
case key_state_0: // 按键初始态
if (!key_press) key_state = key_state_1; // 键被按下，状态转换到键确认态
break;
case key_state_1: // 按键确认态
if (!key_press)
{
key_state = key_state_2; // 按键仍按下，状态转换到计时1
key_time = 0; // 清另按键时间计数器
}
else
key_state = key_state_0; // 按键已抬起，转换到按键初始态
break;
case key_state_2:
if (key_press)
{
key_state = key_state_0; // 按键已释放，转换到按键初始态
key_return = 1; // 输出"1" ，表示单击
key_time = 0;
shangdengcishu = 1; //开短闪灯，告知按下按键成功短按一次
shangdengtime = 3000; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
if (++mimajishu >9)
{
mimajishu = 0;
}
}
else if (++key_time >= 100) // 长按1秒按键时间计数
{
key_state = key_state_3; // 按下时间>1s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 2; // 长按超过1秒后输出"2" ，
shangdengcishu = 1; //开短闪灯，告知按下按键已经有1秒，此后3秒内松开手就关门
shangdengtime = 60000; //设置闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
key_time = 0; // 清按键计数器
}
else if (++key_time >= 250) // 长按达到3.5秒按键时间计数
{
key_state = key_state_4; // 按下时间>3.5s，状态转换到计时2
key_time = 0; // 清按键计数器
key_return = 3; //长按2秒，进入设置界面
shangdengcishu = 3; //开长闪灯
shangdengtime = 65000; //设置长闪灯时间
guangdengtime = 10000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break;
}
return key_return;
}
unsigned char read_key_driver(void) //按键密码输入记录部分
{
static unsigned char i = 0,aj_state = 0;
unsigned char key_return = 0;
#asm("WDR") //喂狗
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
read_key_n();
switch (aj_state)
{
case 0:
if (ermiao_ok)
{
if(i < 5) //密码位数设置
{
mima[i] = mimajishu; //记录第一位密码
mimajishu =0;
PORTB ^= 1<<5; //观察第一位密码识别
aj_state = 1;
qingling(); //清零
i=++i;
shangdengcishu = i; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 3000; //设置闪灯时间
guangdengtime = 17000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
}
break;
case 1:
if (i == 5) //密码识别位数确认，闪2次标示密码输完
{
i=0;
aj_state = 0;
key_return = 1;
}
else
aj_state = 0;
break;
}
return key_return;
}
}
void main(void)
{
// Declare your local variables here
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
// Input/Output Ports initialization
// Port B initialization
// Func5=In Func4=In Func3=In Func2=In Func1=In Func0=Out
// State5=T State4=T State3=T State2=T State1=T State0=0
//PORTB = 0xE6; //11100110
//DDRB = 0x39; //00100001，PB.0和5配置为输出，其它位为输入
PORTB=0x3A;
DDRB=0x39;
delay_ms(100);
/*上电恢复初始密码*/
PORTB |=( 1<<0); //PD7输出高
DDRB &=~( 1<<0); //PD7设置成输入
if(PINB.0 == 0) //若PD7拉低就把密码恢复出厂设置
{
shangdengcishu = 5; //开短闪灯标示刚才输入一位密码成功
shangdengtime = 15000; //设置闪灯时间
guangdengtime = 10000; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEPE));
EECR = (0<<EEPM1)|(0<<EEPM0);
EEARL = j+10;
EEDR = huifu[j]; //恢复默认密码
EECR |=(1 <<EEMPE);
EECR |=(1 <<EEPE);
ysmima[j] = huifu[j]; //密码立即生效
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
//delay_ms(5000);
}
//while(PIND.7 == 0) {;}
//PORTB = 0xE6; //11100110
//DDRB = 0x39; //00100001，PB.0和5配置为输出，其它位为输入 // PD7为输出方式，默认输出低电平
PORTB=0x3A;
DDRB=0x39;
#asm("cli")
#asm("sei")
for(j=0;j<5;j++) //读出原密码
{
while(EECR &(1 <<EEPE));
EEARL = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
delay_ms(10);
}
#asm("cli")
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 125.000 kHz
// Mode: CTC top=OCR0A
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x02;
TCCR0B=0x03;
TCNT0=0x00;
OCR0A=0xF9;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFF
// OC1A output: Disconnected
// OC1B output: Disconnected
// Timer1 Overflow Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
PLLCSR=0x00;
TCCR1=0x00;
GTCCR=0x00;
TCNT1=0x00;
OCR1A=0x00;
OCR1B=0x00;
OCR1C=0x00;
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Low level
// Interrupt on any change on pins PCINT0-5: Off
GIMSK=0x00; //禁用INT0中断，等合适的时候再打开
MCUCR=0x00;
GIFR=0x40;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x10;
// Universal Serial Interface initialization
// Mode: Disabled
// Clock source: Register & Counter=no clk.
// USI Counter Overflow Interrupt: Off
USICR=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
ACSR=0x80;
ADCSRB=0x00;
DIDR0=0x00;
// ADC initialization
// ADC disabled
ADCSRA=0x00;
// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/2k
// Watchdog Timer interrupt: Off
#pragma optsize-
#asm("wdr")
WDTCR=0x18;
WDTCR=0x08;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
// Global enable interrupts
#asm("sei") // 开放全局中断
while (1)
{
switch (status)
{
case 0:
if (key_stime_ok) // 10ms到，键处理
{
key_stime_ok = 0;
switch(read_key_n())
{
case 0:
status = 0;
break;
case 1:
status = 1;
break;
case 2:
PORTB &= ~(1<<3);
PORTB |= (1<<4); //关门
DDRB = 0x39;
break;
}
}
break;
case 1:
if (read_key_driver() ==1 )
{
qingling(); //清零
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5)
{
cnt=0;
//PORTB ^= 1<<3;
status = 3;
shucuo=0;
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;/*mima[1] = 0; mima[0] = 0;*/ //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
PORTB &=~(1<<5);
PORTB &=~(1<<4);
PORTB |=(1<<3); //开门
DDRB = 0x39;
}
else {status = 2;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 2:
while(shucuo==3) //输错3次就锁死300秒
{
#asm("WDR") //喂狗
if(shucuo_ok)
{
qingling(); //清零
status = 0;
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;
}
}
status = 0; //输错3次前继续放回等待输入命令，注意如果之后没有按键转入掉电模式后是否记忆之前输错的次数，以防产生BUG，不然输错两次，
break; //等转入掉电模式后，又可以唤醒继续输入，这样就惨了！
case 3:
if (read_key_n() == 3) //长按3.5秒进入密码设置部分
{
status = 12;
}
else if (ermiao_ok) {status = 0;}
break;
case 12: //老密码输入对，开始第一次输入新密码
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++)
{
ysmima[j]=mima[j];
}
status = 13;
}
break;
case 13: //开始第二次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5)
{
cnt=0;
//PORTB ^= 1<<3;
status = 14;
shucuo=0;
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;
//mima[1] = 0; mima[0] = 0;
} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 14: //开始第三次输入新密码，并和第一次的对比
if (read_key_driver() ==1 )
{
for(j=0;j<5;j++) //密码对比识别
{
if (mima[j]==ysmima[j])
{
cnt++;
}
}
if (cnt==5)
{
cnt=0;
PORTB ^= 1<<5; //观察
status = 15;
shucuo=0;
shangdengcishu = 3;
shangdengtime = 50000;
guangdengtime = 10000;
kaidengduibi=1;
//mima[1] = 0; mima[0] = 0;
} //密码输对后PORTB = 0xFD; //执行开门，PB1拉低
else {status = 16;++shucuo;cnt=0;/*mima[1] = 0; mima[0] = 0;*/} //即使密码不对，也得清零，不然会影响下一次正确密码的判断
}
break;
case 15: //第三次输对新密码后，开始记录
shangdengcishu = 1;
shangdengtime = 50000;
guangdengtime = 0;
kaidengduibi=1;
for(j=0;j<5;j++) //写入新设置密码
{
#asm("cli")
while(EECR &(1 <<EEPE));
EECR = (0<<EEPM1)|(0<<EEPM0);
EEARL = j+10;
EEDR = mima[j];
EECR |=(1 <<EEPM1);
EECR |=(1 <<EEPM0);
ysmima[j] = mima[j]; //密码立即生效
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
status = 0;
break;
case 16:
if(shucuo==3) //设置密码输错3次，重设密码失败就执行某行动
{
for(j=0;j<5;j++) //读出原密码继续使用
{
#asm("cli")
while(EECR &(1 <<EEPE));
EEARL = j+10;
EECR |=(1<<EERE);
ysmima[j]=EEDR;
#asm("WDR") //喂狗,写得慢，要及时喂狗
delay_ms(10);
#asm("sei")
}
shucuo =0 ; //执行输错后也要清零，不然以后再错就没法执行了
PORTB ^= 1<<5; //某行动
status = 0;
}
else status = 12;
break;
}
if (ershimiao_ok) //20秒无动作后休眠
{
shucuo=0; //2次输错密码，若没有再输入密码，进入休眠就清除记录
qingling(); //清零
//PORTB = 11100110; //11100110进入休眠前关所有灯
//DDRB = 00100001; //00100001，PB.0和5配置为输出，其它位为输入
PORTB |=( 1<<1); //置位
PORTB &=~( 1<<0); //清零
DDRB = 0x39;
TIMSK = 0x00; //关闭T/C0比较匹配中断
/*关闭看门狗省电*/
//#asm("cli") //关闭全局中断
#asm("WDR") //喂狗
//MCUSR = 0x00;
//WDTCR |= (1<<WDCE) | (1<<WDE);
//WDTCR = 0x00;
MCUSR &= ~(1<<WDRF);
WDTCR |= (1<<WDCE) | (1<<WDE);
WDTCR &= ~(1<<WDE);
#asm("sei") // 开放全局中断
/*使能INT0中断*/
GIMSK=0x40;
MCUCR=0x00;
GIFR=0x40;
MCUCR |= (1<<SM1) | (0<<SM0); // 掉电模式
MCUCR |= (1<<SE); //睡眠使能
#asm("sleep") //休眠
PORTB ^= 1<<5; //唤醒后监测
}
#asm("WDR") //喂狗
shangdeng(); //扫描闪灯
}
}

复制代码

biying · 发表于 2014-5-6 08:37:51

为什么在某次编译的时候提示Linker error: the program has no 'main' function，关掉软件再打开就没有提示了，但是点里面的那些括号不在变成黄色的提示。这是怎么回事呢？

biying · 发表于 2014-5-6 17:32:31

这个程序为什么PB2会长亮？为什么INT0不能唤醒

biying · 发表于 2014-5-8 18:44:17

本帖最后由 biying 于 2014-5-8 20:25 编辑

attiny13A和attiny85用CodeWizardAVR编译，INT0死活不能用（ICCV7 for AVR里改为INT0后居然是正常的！），还好PC_INT0可以用，终于调通了（密码还不能记录到片内EEPROM，应该是写程序有问题），这是文件包，休眠电流测试了一下，休眠后串了个5K电阻，测试的压降为2.38毫伏，算下来掉电模式的电流为0.476微安，真的不错啊！接下来INT0死活不能用继续找吧，还要找找BUG和优化代码。还有担心这两个IO 直接引出2米长的线来是否会出问题。唉，太费时间了！

biying · 发表于 2014-5-8 20:27:37

搞定密码设定后写入片内EEPROM，原来是那些写相关的位名称不对

biying · 发表于 2014-5-13 07:51:58

现在发觉输入密码太慢，准备改成长按按键通过闪灯来识别密码（有泄露密码的可能），到时改成可以随意设置密码位数（6位以内），改之前再保存一次

biying · 发表于 2014-5-15 07:07:36

read_key_n(void)中，以下程序如果不注释，仿真的时候居然会运行，

case key_state_3:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
key_time = 0; // 清按键计数器
key_return = 5; //密码录入完成
}
else if (++key_time >= 50) // 每0.7秒闪一次计数
{
if (++mimajishu >9)
{
mimajishu = 0;
}
key_time = 0; // 清按键计数器
shangdengcishu = 1; //开长闪灯
shangdengtime = 3000; //设置长闪灯时间
guangdengtime = 0; //设置关灯时间
kaidengduibi=1; //判断上一次闪灯是否结束，实现新开灯时能马上看到效果
}
qingling(); //清零
break;
//以下程序如果不注释，仿真的时候居然会运行
/* case key_state_4:
if (key_press)
{
key_state = key_state_0; //按键已释放，转换到按键初始态
}
qingling(); //清零
break; */
}
return key_return;

复制代码

biying · 发表于 2014-5-19 02:07:35

本帖最后由 biying 于 2014-5-19 02:22 编辑

长按按键来数LED灯闪的次数来输入密码，代码完成，用M16调试的

biying · 发表于 2014-5-19 04:29:20

本帖最后由 biying 于 2014-5-19 04:30 编辑

移植到tiny85上来了，很不顺利，搞了2个多小时，问题解决了，但是原因不明，难道真的得上TINY的仿真器来找原因吗？

一条奇怪的指令搞定ATTINY85
http://www.amobbs.com/thread-5581468-1-1.html
(出处: amoBBS 阿莫电子论坛)

biying · 发表于 2014-5-21 14:35:14

本帖最后由 biying 于 2014-5-21 16:56 编辑

现在改成片内128K主频后，下载只能通过高压编程器，ISP没用了，且必须断开PB0接到ISP的线，不然会导致按键灯长亮，也就是进入了恢复密码设置后的那段代码，这个问题让我浪费一天时间。在程序的按键状态机中，不仅那条1毫秒的延时不需要了，而且端口改变之后接着读端口状态之前那条空指令“#asm("nop") //如果没有这条延时的话，长按按键，闪一次灯就表现出 key_return = 5;的现象，也就是说闪6次后等于输入了6个密码1。”也不需要了。这点手册上没有写吧？看来CPU主频不同，各种怪问题也都来了。通过统计循环次数来闪灯的方法在这里不灵了，定时器的时间是准的呢，怎么怎么长按按键1.7秒后看到闪灯，但之后闪灯间隔由0.7秒变成4秒多？百思不得其解，于是我把闪灯函数改成定时器触发，这样以后改变主频也不用来调里面的参数了。这样一改后所有功能正常了

这是按键和灯接线图

biying · 发表于 2014-5-21 15:04:03

不小心输入了一个0，导致编译提示出错Warning: C:\tiny85-128k\tiny85-128k.c(243): expression with possibly no effect和Error: C:\tiny85-128k\tiny85-128k.c(243): ';' expected, but 'P' found

biying · 发表于 2014-5-23 23:14:07

本帖最后由 biying 于 2014-5-23 23:16 编辑

接上长按键线后测试发现，那条按键后的1毫秒延时必须加上，否则长按按键还是出现2秒闪一次，标示输入的密码是1。初学之路果然充满坑洞。

unsigned char read_key_n(void)
{
static unsigned char key_state = 0, key_time = 0;
unsigned char key_press, key_return = 0;
duankouPORTD |=( 1<<key_LED_fu); //置位
duankouPORTD &=~( 1<<key_LED_zheng); //清零
duankouDDRD &=~( 1<<key_LED_fu);
#asm("nop") //端口操作后插入空指令能正确读端口
delay_ms(1); // 当时钟为片内8M时，如果没有这条延时的话，长按按键，闪一次灯就表现出 key_return = 5;的现象，也就是说闪6次后等于输入了6个密码1。当时钟为片内128K时，在板上仿真可以不用这条，但当接上5米的线再到按钮时，故障出现，加上这条就OK了。
key_press = key_input; // 读按键I/O电平

复制代码

biying · 发表于 2014-5-24 10:26:01

本帖最后由 biying 于 2014-5-24 10:36 编辑

奇怪，为了提高抗干扰能力，在开、关门后添加100毫秒延时，编译后占用的程序存储量居然减小了

void opendoor(void) //开门
{
duankouPORTD &=~((1<<Monitor_LED)|(1<<close_door));
duankouPORTD |=(1<<open_door); //开门
duankouDDRD |=(1<<open_door)|(1<<close_door);
delay_ms(100);//防止开继电器干扰单片机
}
void closedoor(void) //关门
{
duankouPORTD &=~((1<<Monitor_LED)|(1<<open_door));
duankouPORTD |= (1<<close_door); //关门
duankouDDRD |=(1<<open_door)|(1<<close_door);
delay_ms(100);//防止开继电器干扰单片机

复制代码

machao · 发表于 2014-5-24 17:58:03

从那里学到的，软件延时100ms能防止继电器干扰单片机？

biying · 发表于 2014-5-26 00:05:10

machao 发表于 2014-5-24 17:58
从那里学到的，软件延时100ms能防止继电器干扰单片机？

马老师问的好啊，是我错了，我应该注明：从某处学来的，还未经证实！以前在本论坛看到过有说继电器通电后延时几十毫秒可以防止继电器通电的电流冲击干扰单片机，具体哪篇我现在都找不到了。实际测试电控门之前，我就加了这么一条写了一片TINY85备用。但从昨天现场的测试结果来看，这片没用上。但昨天的测试我很不满意，原因：原电控器在开门和关门切换之间，有先释放A继电器后再开B继电器的步骤，我的没有，这点之前被我疏忽了，因为继电器在断电的很短时间内会仍然吸合，此时马上开另一组继电器的话，在某些场合可能导致短路。还有在开门的过程中我想马上停止，甚至在关门的过程中我想马上开门，这种情况可以应对某些突发情况，比如开关时电机卡死，关门时突然小猪跑出来等，原控制器上是分别有开门、停止、关门按键的，而现在用一个按键来实现这三个功能的话，我得再修改程序，有了之前的基础，现在感觉改程序轻松多了。初步定为单片机上电初始状态为等待输入密码开门（此时短按可以关门），密码正确后开门，此时若短按按键就停止，再短按按键就关门，再短按按键就停止，再再短按按键就开门，如此循环，直到没有任何操作30秒后（开关门时间为30秒内完成）自动返回初始状态。前几天媳妇的本田自由TODAY摩托车忘记开报警器，被小偷光顾，无奈机头质量太好太牢靠，小偷把机头硬扳歪许多也没有把前轮撇直，害得我第二天费了好大劲才把机头扭回原位。之前从自已的电动车第三次被撬终于被偷走，到半年后在路上找回，我早就想搞车用自动上锁报警喇叭兼断电报警器和无钥匙启动，当然也是用一个按键来操作，看来得抓紧时间了。

biying · 发表于 2014-5-26 01:34:01

本帖最后由 biying 于 2014-5-26 01:40 编辑

根据上述改动，做出新的代码了，在马老师AVR仿真板上测试通过。现在做得有点打瞌睡了，以前是改到兴奋的时候就不困了。
现在想起一个问题来了：这个车库门上是里外各装有一个按键的，当在里面输入密码的时候，里面的按钮被人挡着看不见，可外面那颗并联的按钮是没有人遮挡呢，这样还不泄露密码？难道要分别占用两组端口来分别控制？

machao · 发表于 2014-5-27 00:13:54

1/继电器的控制是通过线圈，它是一个电感。当通断的瞬间会产生一个反相电动势，这个电动势与原电压叠加产生一个瞬间高压，回将驱动三极管击穿。通常在线圈两端并接一个反峰二极管和吸收电容就能很好的抑制掉。这个与延时无关。
2/继电器是机械动作，一次完全导通或断开需要20ms。如果你说断开A，延时100ms后再通B，这是对的，断开A后，延时100ms，A彻底断开了，然后再通B，不会造成电源短路。这个也就是现在的MCU用T/C产生PWM控制电机，带有死区时间设置和产生功能的原因。但这个不是防止干扰单片机，而是防止瞬间电源的短路。
3/你现在要作一个能实际使用的DD，而在实验板上的验证与实际情况差别是非常大的。况且我发现你对实际情况还没有充分的进行分析。比如，系统如何知道现在大门是开的还是关闭的？在关门的过程中，如何知道门已经是关上了？（如果门已经关上了，而系统继续给电机通电的话，此时门已经不能动了，那么电机也可能会烧毁掉，或者门变形了（电机功率很大的情况下）。tiny85只有6个I/O，一个按键、一个LED、一个A继电器，一个B继电器，还有2路作什么用？

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
你应先贴上电路图，把需求和功能描述的准确些。

biying · 发表于 2014-5-27 12:48:59

machao 发表于 2014-5-27 00:13
1/继电器的控制是通过线圈，它是一个电感。当通断的瞬间会产生一个反相电动势，这个电动势与原电压叠加产生 ...

谢谢马老师，我之前没有把使用环境描述清楚，因为觉得原理太简单所以没有画出电路图来。原被控制的电机为杜亚管状电机，内部已经有限位开关，输出为4根线，即：地线、零线、正转（火线）、反转（火线），不管正转还是反转，电机内部顶到限位开关后就自动断电保护电机了。我测试了一下这道卷帘门，开、关门时间各为27秒。根据这一特点，我只要控制板输出30秒后休眠即可。关于如何让系统判断门现在是开还是关，我是设计成让人来判断的，也就是说假设大门为开着的，那么关门的人只要短按按钮就可以关门；假设大门是关着的，那么开门的人就得先输入正确的密码，然后就会马上开门，之后短按就会在停止、关门、停止、开门这样循环，直到没有按按钮30秒后休眠。现在的问题是因为是直接控制原门控器上的继电器，如果此时用遥控器的话就会和密码锁冲突，导致短按密码锁不能关门（原控制器开门后继电器会通电3分钟，只有等3分钟过后才可能用密码锁关门）。所以我现在要把密码锁输出改接到原门控器手动按钮上，输出几十毫秒的低电平（模拟手按按钮）应该就可以了。现在想到的这些问题我都能根据需要来改程序了，可就是那个TINY85的INT0为什么没有反应呢，请马老师再指点一下吧，谢谢！这是原来测试TINY85的INT0的代码：

/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.1b Evaluation
Automatic Program Generator
http://www.hpinfotech.com
Project :
Version :
Date : 2014-5-24
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
Chip type : ATtiny85
AVR Core Clock frequency: 8.000000 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 128
*****************************************************/
#include <tiny85.h>
#include<delay.h>
// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here
GIMSK=0x00; //禁用INT0中断，等合适的时候再打开
GIFR=0x40;
PORTB ^= 1<<4;
}
// Declare your global variables here
void main(void)
{
// Declare your local variables here
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
// Input/Output Ports initialization
// Port B initialization
// Func5=Out Func4=Out Func3=Out Func2=Out Func1=In Func0=Out
// State5=1 State4=1 State3=1 State2=1 State1=P State0=1
PORTB=0x3F;
DDRB=0x3D;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFF
// OC1A output: Disconnected
// OC1B output: Disconnected
// Timer1 Overflow Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
PLLCSR=0x00;
TCCR1=0x00;
GTCCR=0x00;
TCNT1=0x00;
OCR1A=0x00;
OCR1B=0x00;
OCR1C=0x00;
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Low level
// Interrupt on any change on pins PCINT0-5: Off
GIMSK=0x40;
MCUCR=0x03;
GIFR=0x40;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;
// Universal Serial Interface initialization
// Mode: Disabled
// Clock source: Register & Counter=no clk.
// USI Counter Overflow Interrupt: Off
USICR=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
ACSR=0x80;
ADCSRB=0x00;
DIDR0=0x00;
// ADC initialization
// ADC disabled
ADCSRA=0x00;
// Global enable interrupts
#asm("sei")
while (1)
{
// Place your code here
// Place your code here
delay_ms(4000);
PORTB ^= 1<<3;
GIMSK=0x40;
}
}

复制代码

这是程序包：

machao · 发表于 2014-5-27 15:42:37

/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.3 Standard
Automatic Program Generator
?Copyright 1998-2011 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project :
Version :
Date : 2014-5-27
Author  : PerTic@n
Company : If You Like This Software,Buy It
Comments:

Chip type             : ATtiny85
AVR Core Clock frequency: 8.000000 MHz
Memory model          : Small
External RAM size    : 0
Data Stack size       : 128
*****************************************************/

#include <tiny85.h>

// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here

}

// Declare your global variables here

void main(void)
{
// Declare your local variables here

// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port B initialization
// Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State5=T State4=T State3=T State2=P State1=T State0=T
PORTB=0x04;
DDRB=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFF
// OC1A output: Disconnected
// OC1B output: Disconnected
// Timer1 Overflow Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
PLLCSR=0x00;

TCCR1=0x00;
GTCCR=0x00;
TCNT1=0x00;
OCR1A=0x00;
OCR1B=0x00;
OCR1C=0x00;

// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// Interrupt on any change on pins PCINT0-5: Off
GIMSK=0x40;
MCUCR=0x03;
GIFR=0x40;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;

// Universal Serial Interface initialization
// Mode: Disabled
// Clock source: Register & Counter=no clk.
// USI Counter Overflow Interrupt: Off
USICR=0x00;

// Analog Comparator initialization
// Analog Comparator: Off
ACSR=0x80;
ADCSRB=0x00;
DIDR0=0x00;

// ADC initialization
// ADC disabled
ADCSRA=0x00;

// Global enable interrupts
#asm("sei")

while (1)
   {
   // Place your code here

   }
}
================================
1/ 这是我用我的CVAVR生成的代码，版本比你用的高。INT0中断设置为MCUCR=0x03时，应该为上升沿触发。我看了TINY85手册，03是上升沿触发，00是低电平触发。你用的CVAVR有问题。

2/你用低电平中断是唤醒CPU吗？如果不是用于唤醒CPU，最好采用边沿触发中断方式。

3/如果是低电平触发中断，那么中断最好这样写：
interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here
   int delay_pb2 = 0;

   // GIMSK=0x00; //禁用INT0中断，等合适的时候再打开=====>这个无用，AVR进中断时自动关闭全局中断响应。
//  GIFR=0x40;       ======>多于，见下面英文。低电平中断不会将中断标志位值“1”,用不到清楚
//  PORTB ^= 1<<4;  ====> CVAVR支持位变量操作，这样直观易理解，而且简短。PORTB ^= 1<<4;要3条汇编完成，而下面只要一条
PORTB.5 = 1                   //LED亮，提示进入中断
while(delay_pb2 <50000)       等待PB2(INT0)彻底稳定恢复高电平后退出中断
{
      if (PINB.2)
         ++delay_pb2;
      else
         delay_pb2 = 0;
｝
PORTB.5=0; //LED灭，提示退出中断
}

• Bit 6 – INTF0: External Interrupt Flag 0
When an edge or logic change on the INT0 pin triggers an interrupt request, INTF0 becomes set (one). If the I-bit in SREG and the INT0 bit in GIMSK are set (one), the MCU will jump to the corresponding Interrupt Vector. The flag is cleared when the interrupt routine is executed. Alternatively, the flag can be cleared by writing a logical one to it.

This flag is always cleared when INT0 is configured as a level interrupt.

4/ INT0的输入是PB2，应该设置成输入方式上拉有效，你初始化设置成输出方式，并输出“1”,那么该引脚是5V输出，你把它拉成低电平触发中断，相当把5V正与地断路，会有大电流从PB2流出，容易将PB2引脚烧毁。

biying · 发表于 2014-5-28 02:23:58

本帖最后由 biying 于 2014-5-28 10:23 编辑

machao 发表于 2014-5-27 15:42
/*****************************************************
This program was produced by the
CodeWizardAV ...

谢谢马老师指点！之前我是先看TINY13A中文版数据手册，以为TINY系列8只脚的引脚功能定义是一样的，后来看TINY85的数据手册只有英文手册，就没有看引脚定义，只是对照寄存器、融丝、EEPROM如何定义，所以之前测试TINY85的INT0时，真正的INT0让我接到了共阳LED灯上，导致我误以为TINY85的INT0不起作用。这实在是我的粗心大意造成。
1、我选用低电平中断就是为了唤醒CPU
2、// GIMSK=0x00; //禁用INT0中断，等合适的时候再打开。这条我是为了在密码锁中唤醒后不再用INT0，而把INT0当作普通输入端口而写的。
      //  GIFR=0x40;这条我也看了数据手册，我也觉得没用，但当时实在找不出原因才加上这条试试的。
      PORTB.5 = 1 //LED亮，提示进入中断这个要用PB5来点灯，应该在融丝里把PB５的复位功能禁用，太麻烦不方法调试我才换成PB4，而我接的是仿真板上A区的共阳LED,输出1时是不亮灯的。
   3、  您举的低电平触发中断写法我看懂了，相当于按键消抖，松开按键后才退出中断程序，不过这个delay_pb2 <50000延时我测试下来非常短，不知道为什么会这样？我甚至还增加了延时,可效果是一样的，真是奇怪

interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here
unsigned int delay_pb2 = 0,i; //定义一个变量
PORTB.4 = 0;//LED亮，提示进入中断
while(delay_pb2<50000) //等待PB2(INT0)彻底稳定恢复高电平后退出中断
{
if (PINB.2)
{
for(i = 0;i<1140;i++)
{
++delay_pb2;
}
delay_pb2 = 0;
}
else
delay_pb2 = 0;
}
PORTB.4=1; //LED灭，提示退出中断
}

复制代码

后来我改成这样就有长延时的效果了

interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here
unsigned int delay_pb2 = 1,i,j; //定义一个变量
PORTB.4 = 0;//LED亮，提示进入中断
while(delay_pb2) //等待PB2(INT0)彻底稳定恢复高电平后退出中断
{
if (PINB.2)
{
for(i = 0;i<500;i++)
{
for(j = 0;j<1140;j++);
}
delay_pb2 = 0;
}
else
delay_pb2 = 0;
}
PORTB.4=1; //LED灭，提示退出中断
}

复制代码

4、还有那个INT0中断触发方式，如果选任意逻辑电平变化触发中断的话，在以下的代码中，我测试下来发现在PORTB.3 = 0;//亮灯时按一下按键不会马上进入中断程序，而是等PORTB.3 = 1；然后再到PORTB.3 = 0时，才会执行时中断程序；如果在PORTB.3 = 1时按一下按键，一样不会响应中断程序，而是要等PORTB.3 = 0时才响应，想不通啊！然后如果把中断服务程序里的GIMSK=0x00;去掉的话，在 PORTB.3 = 0;//亮灯和PORTB.3 = 1;状态时短按按键都是可以马上响应INT0的。

#include <tiny85.h>
#include<delay.h>
// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here
unsigned int delay_pb2 = 1,i,j; //定义一个变量
GIMSK=0x00; //禁用INT0中断，等合适的时候再打开
PORTB.4 = 0;//LED亮，提示进入中断
while(delay_pb2) //等待PB2(INT0)彻底稳定恢复高电平后退出中断
{
if (PINB.2)
{
for(i = 0;i<500;i++)
{
for(j = 0;j<1140;j++);
}
delay_pb2 = 0;
}
else
delay_pb2 = 0;
}
PORTB.4=1; //LED灭，提示退出中断
}

复制代码

主循环是这样的：

while (1)
{
// Place your code here
// Place your code here
PORTB.3 = 0;//亮灯
//#asm("nop") //端口操作后插入空指令能正确读端口
GIMSK=0x40;//亮灯时开INT0
delay_ms(4000);
PORTB.3 = 1;
delay_ms(4000);
}

复制代码

biying · 发表于 2014-5-30 17:17:50

本帖最后由 biying 于 2014-5-30 17:35 编辑

为了调试方便，把融丝改为62D7，使用片内8M。为了不和遥控器冲突，把控制继电器直接改接到原控制板的三个控制按钮上来实现开门、关门、停止的功能。此时把监视LED端口改接到停止按钮上。为了防止初始状态关门时有意外，添加再短按就停止、再按关门、再按停止如此循环，在此循环中若长按的话依然转入密码输入状态。

biying · 发表于 2014-5-31 07:20:46

之前密码位数是可以自己在6位以内设定，但是如果是6位以内时，初始状态时输入完密码得等4秒后才能有输出动作。现在改为设为6位以内时，输入完密码马上动作，代价是代码增加186字节。

biying · 发表于 2014-6-3 01:09:52

今天测试出上电原控制器的停止按钮没有作用，得等输对一次密码后，才能起作用，现在顺便添加休眠前闪灯

biying · 发表于 2014-6-17 03:46:12

本帖最后由 biying 于 2014-6-17 03:58 编辑

今天在调试报警器时发现这个密码锁里的一个BUG，实践中还没发现问题，但理论上分析出问题了，就是原休眠程序中没有status = 0这条，按理应该唤醒后会继续跑密码输对后的循环。之前只是想着密码输对开门，然后30秒后休眠，忘记了休眠后唤醒程序是接着跑呢，先上修改后的程序

biying · 发表于 2014-6-21 00:46:51

找到为什么之前没出问题的原因了，原来我己经在PC-INT0中断里添加status = 0这条了。

biying · 发表于 2014-8-14 00:11:37

昨天在大门边做氩弧焊作业，后来发现这个单片机密码老输不对，做恢复密码的操作不起作用（可以休眠，原控制板功能也正常），看来单片机被远程烧掉了。以前在票据打印机旁边做氩弧焊作业，同样烧掉一台票据打印机。看来这个氩弧焊太强大了。

biying · 发表于 2015-3-10 09:59:12

这个单按钮接线有2米长，其中大部分是在铝合金型材中，但是经过半年的测试，我发现单片机容易受干扰，看来得改在按钮上直接做个发射编码，然后在控制盒里再解码，这样控制才可靠。得抽时间学编解码了。

初学单片机-单键密码锁制作日志-遇到问题

本帖子中包含更多资源

阿莫论坛20周年了！感谢大家的支持与爱护！！

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源