MCU暂停运行程序，等待唤醒命令

单片机可不可以运行到某处暂停（休眠），然后等触发按键后才继续运行下面程序呢？不是跳转运行其他程序，是暂停，就是什么也不做，先停一下，然后按键松开后才继续

可以，低功耗模式

运行到某处进入循环暂停，当某键按下跳出循环继续向下执行。

可以设置下降沿中断，单片机休眠，按键按下，0V唤醒单片机。从休眠下一条指令开始执行！

空闲模式  外部中断唤醒  

zgrfox110 发表于 2023-7-30 22:08
可以设置下降沿中断，单片机休眠，按键按下，0V唤醒单片机。从休眠下一条指令开始执行！

有没相应的程序看看是怎样的呢？

1860774xxxx 发表于 2023-7-30 22:18
空闲模式  外部中断唤醒

有没相应程序学下呢

taotie 发表于 2023-7-30 20:38
运行到某处进入循环暂停，当某键按下跳出循环继续向下执行。

就是在里面空转咯？这个可以试试。

农民阿伯 发表于 2023-7-31 01:21
有没相应程序学下呢

芯片手册自己看看贝 空闲模式和掉电模式

农民阿伯 发表于 2023-7-31 01:23
就是在里面空转咯？这个可以试试。

不可以，空转太费电了，进入休眠状态连时钟都停了才能真正做到省电。

设置一个条件，当满足条件，MCU进入休眠。当用按键或其它方式触发唤醒，MCU继续工作。给你一个示例参考

1. //适合STC15/STC8系列，测试平台 TX-1C 开发板
   
2. //#include <STC15F2K60S2.H>
   
3. #include <STC8H.H>
   
4. #include "intrins.h"
   
5. #define uchar unsigned char
   
6. #define uint unsigned int
   
7. 
   
8. sbit key  = P3^2;//S14
   
9. sbit GND  = P3^4;//矩阵键盘P3.4模拟接地
   
10. 
    
11. uchar Temp;
    
12. uchar Key_value; //键值
    
13. uint  keyTim;    //按键时长
    
14. bit   flag1ms;   //1ms中断标志
    
15. bit   on_off;    //开关标志
    
16. bit   allow;     //允许关机标志
    
17. 
    
18. void Timer0Init(void)//1毫秒@11.0592MHz
    
19. {
    
20.         AUXR |= 0x80;                //定时器时钟1T模式
    
21.         TMOD &= 0xF0;                //设置定时器自动重载模式
    
22.         TL0 = 0xCD;                        //设置定时初始值
    
23.         TH0 = 0xD4;                        //设置定时初始值
    
24.         TF0 = 0;                                //清除TF0标志
    
25.         TR0 = 1;                                //定时器0开始计时
    
26.         ET0 = 1;                                //允许T0中断
    
27. //        EA  = 1;                                //开总中断
    
28. }
    
29. 
    
30. void key_scan()    //按键扫描函数
    
31. {
    
32.         if(flag1ms)  //1ms时间标志
    
33.         {
    
34.                 flag1ms = 0;//1ms时间标志清0
    
35.                 if(!key && !on_off)
    
36.                 {
    
37.                         if(++keyTim>1000)keyTim=1001;//防止溢出
    
38. 
    
39.                         if(keyTim==20) //大于20ms小于1s算短按
    
40.                         {
    
41.                                 Key_value=0x01;
    
42.                         }
    
43.                         if(keyTim==1000) //达到1s算长按
    
44.                         {
    
45.                                 Key_value|=0x10;
    
46.                         }
    
47.                 }
    
48.                 else
    
49.                 {
    
50.                         keyTim=0;        //按键松手keyTim清0
    
51.                         on_off=0;        //开关标志清0
    
52.                 }
    
53.         }
    
54. }
    
55. 
    
56. void key_service()//按键服务函数
    
57. {//短按等松手响应，长按达1s不论是否松手即响应
    
58.         if((keyTim==0||keyTim==1000) && Key_value!=0x00)
    
59.         {
    
60.                 if(Key_value==0x01)//短按任务
    
61.                 {
    
62.                         Temp++;
    
63.                         P1=~Temp;
    
64.                 }
    
65.                 if(Key_value==0x11)//长按关机
    
66.                 {
    
67.                         allow=1;
    
68.                 }
    
69.                 Key_value=0x00;//任务完成后键值清0
    
70.         }
    
71. }
    
72. 
    
73. void Shutdown()//掉电模式函数
    
74. {
    
75.         if(allow)
    
76.         {
    
77.                 P1=0xff;                //关闭LED显示
    
78.                 //关闭所有在用硬件，减小能耗
    
79.                 EX0 = 1;                //打开中断
    
80.                 PCON = 0x02;//MCU进入掉电模式
    
81.                 _nop_();    //掉电模式被唤醒后,首先执行此语句,然后再进入中断服务程序
    
82.                 _nop_();    //中断服务程序执行完再接着此句继续执行
    
83.                 EX0 = 0;                //关闭中断
    
84.                 while(!key);//等待按键松手，防止按键扫描程序误读
    
85.                 //打开所有在用硬件，恢复正常运行
    
86.                 P1=~Temp;                //恢复LED显示
    
87.                 allow=0;                //清0
    
88.         }
    
89. }
    
90. 
    
91. void main()
    
92. {
    
93.         P0M0 = 0x00;//初始化IO
    
94.         P0M1 = 0x00;
    
95.         P1M0 = 0x00;
    
96.         P1M1 = 0x00;
    
97.         P2M0 = 0x00;
    
98.         P2M1 = 0x00;
    
99.         P3M0 = 0x00;
    
100.         P3M1 = 0x00;
     
101.         P4M0 = 0x00;
     
102.         P4M1 = 0x00;
     
103.         P5M0 = 0x00;
     
104.         P5M1 = 0x00;
     
105.         P6M0 = 0x00;
     
106.         P6M1 = 0x00;
     
107.         P7M0 = 0x00;
     
108.         P7M1 = 0x00;
     
109.         GND  = 0;
     
110.         IT0 = 1;//设置INT0的中断类型为下降沿唤醒
     
111. //        EX0 = 1;//使能INT0中断
     
112.         EA  = 1;//开总中断                                                        
     
113.         Timer0Init();//定时器初始化函数
     
114.         while (1)
     
115.         {
     
116.                 key_scan();                //按键扫描函数
     
117.                 key_service(); //按键服务函数
     
118.                 Shutdown();                //掉电模式函数
     
119.         }
     
120. }
     
121. //INT0中断服务程序
     
122. void exint0() interrupt 0
     
123. {
     
124.         on_off=1;//开关标志置1
     
125. }
     
126. //T0中断服务程序
     
127. void interruptTimer0() interrupt 1
     
128. {
     
129.         flag1ms = 1;    //1ms标志
     
130. }

复制代码

可以的，有很多方式，有些单片机低功耗的时候就停在程序那里，但是这种功耗肯定不是最低的。

1. //方式一：
   
2. void fun_Enter_LPM(void){
   
3.         ADEN = 0;                                //关闭ADC使能
   
4.         VREFEN = 0;                                //关闭内部参考电压
   
5. 
   
6.         Y_LED = 1;                                //LED灯灭
   
7. 
   
8.     KIF = 0;                                //清按键中断标志
   
9.         KIE = 1;                                //使能按键中断唤醒
   
10.         KMSK0 = 1;                                //打开中断唤醒 (按键)
    
11. 
    
12.         LPM = 0;                                //进入IDLE0模式
    
13.     RCEN = 0;                                //关狗
    
14.     CLRWDT();                                //清除看门狗定时器
    
15.     IDLE();                                        //
    
16.     CLRWDT();                                //清除看门狗定时器
    
17.     RCEN = 1;                                //开狗
    
18.        
    
19.         Y_LED = 0;                                //LED灯亮
    
20. }
    
21. 
    
22. //方式二：
    
23. void fun_Wait_Run(void){
    
24.         while(1){
    
25.                 CLRWDT();                        //清除看门狗定时器
    
26.                 if(X_key == 0){                //按键按下
    
27.                         DelayXms(10);        //阻塞式延时消抖，10ms
    
28.                         if(X_key == 0)        //按键真的按下，不是误动作
    
29.                                 break;                //跳出等待的循环，运行函数调用处之后的程序
    
30.                 }
    
31.         }
    
32. }

复制代码

方式一实现，休眠配合外部中断，需要在进入休眠前使能外部中断
方式二实现，直接调用函数

菜鸟yc 发表于 2023-7-31 09:33
方式一实现，休眠配合外部中断，需要在进入休眠前使能外部中断
方式二实现，直接调用函数

看不懂，还是方法二适合我，慢慢学。请问下，方式二中，如果我是按键释放时跳出循环，语句 if(X_key == 0) 改为if(X_KEY==1)就可以吗？

是的，单片机可以做到这一点。你可以使用中断来实现这个功能。

在你想要暂停的地方，你可以让单片机进入休眠模式或者无限循环等待，然后设置一个按键触发的中断。当按键被按下时，中断会被触发，然后单片机就会从休眠状态唤醒或者跳出无限循环，继续执行下面的程序。

以下是一个简单的示例代码（基于STM32）：

c
#include "stm32f1xx_hal.h"

void EXTI0_IRQHandler(void)
{
  /* 确认中断标志 */
  if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_0) != RESET)
  {
    __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);
   
    /* 在这里添加按键按下后需要执行的代码 */
  }
}

int main(void)
{
  /* 初始化和配置代码... */

  while(1)
  {
    /* 在这里添加主循环代码... */
   
    /* 想要暂停的地方 */
    __WFI(); // 进入休眠模式，等待中断唤醒
   
    /* 按键被按下，中断被触发，单片机唤醒，继续执行下面的代码... */
  }
}
在这个示例中，__WFI()函数使单片机进入休眠模式，等待任何中断来唤醒它。当按键被按下时，EXTI0中断被触发，然后单片机就会被唤醒，继续执行__WFI()之后的代码。

请注意，这只是一个基本的示例，实际的代码可能需要根据你的具体需求进行修改。例如，你可能需要配置GPIO为输入模式，并启用相应的中断；你也可能需要在中断处理程序中添加一些去抖动的代码等。

可以，有的单片机有sleep命令。

进入掉电模式晶振停止震荡，可由外部中断或复位唤醒。

菜鸟yc 发表于 2023-7-31 09:33
方式一实现，休眠配合外部中断，需要在进入休眠前使能外部中断
方式二实现，直接调用函数

能否帮我修改一下，特别是那个看门狗程序，不会弄。
#include"intrins.h"
#include <reg52.h>
#define uchar unsigned char
#define uint  unsigned int
sfr P5 =0xC8;//P5地址
sbit key  = P5^4;
sbit led  = P5^5;

/***********************200ms延时函数*****************************/
void Delay200ms()                //@12.000MHz
{
        unsigned char data i, j, k;

        _nop_();
        _nop_();
        i = 10;
        j = 31;
        k = 147;
        do
        {
                do
                {
                        while (--k);
                } while (--j);
        } while (--i);
}

/***********************10ms延时函数*****************************/
void Delay10ms()                //@12.000MHz
{
        unsigned char data i, j;

        i = 20;
        j = 113;
        do
        {
                while (--j);
        } while (--i);
}

/***********************等待刹车松开函数*****************************/
void fun_Wait_Run(void)
{
        while(1)
        {
                CLRWDT();                     //清除看门狗定时器
                if(key == 1)                  //按键松开
                {                           
                        Delay10ms();         //阻塞式延时消抖，10ms
                     if(key == 1)          //按键真的松开，不是误动作
                     {        
                          break;          //跳出等待的循环，运行函数调用处之后的程序
                     }
                 }
        }
}

/******************主程序**********************/
void main()
{
        while(1)
         {
                 if(key == 0)                     //刹车
                 {
                    Delay10ms();                   //延时消抖，10ms
                    if(key == 0)
                     {                             //真刹车。
                        led = 0;                     //输出低电平。
                        Delay200ms();                //输出延时。
                      }
                   fun_Wait_Run;                  //等待松开手刹
                  }
                 if(key == 1)                      //松开手刹
                 {
                    Delay10ms();                 //延时消抖，10ms
                    if(key == 0)                 //真松开手刹。
                     {
                        led = 0;                 //输出低电平。
                        Delay200ms();             //输出延时。
                        led = 0;                  //再次输出低电平。
                        Delay200ms();
                      }
                  }
         }
}

自己顶上去，求助高手给弄下