EmergencyButton-mcu/main.cb2

////////////////////////////////////////////////////////////////////////////////





//#define     IsDebug
//#define     tim2Led

//#define     RxTestDebug

////////////////////////////////////////////////////////////////////////////////


#include <iostm8s003f3.h>





#define KEY0            KEY[0]                  //����
#define KEY1            KEY[1]                  //������ťȡ������

//==============================================================
  __root unsigned int     BUS_RevBuf[30];
  __root unsigned char    BUS_RevIndex=0;
  __root unsigned char    BUS_Rev_Cmd[3];              //���߽���
  
  __root unsigned int     BUS_RevOverTime=0;           //���߽��ճ�ʱ,200
  __root unsigned char    Bus_RevFlag=0;               //���߽��ճɹ�
//==============================================================

  __root unsigned char    Ledswitch=2;                    //RedLED����
  __root unsigned char    KEY[2]={0};                     //����

//============================================    
  __root unsigned char    BUS_SendInex=0;
  __root unsigned char    BUS_SendCmd[30];              //Ӧ�ò㷢������
  __root unsigned char    BUS_SendingCmd[30];           //��ʱ�����ڴ�������
//==============================================================

  __root unsigned long    LocalTime=0;
  __root unsigned char  RunMode=0;               //0����ʾע��ģʽ��>0��ʾ��������ģʽ
  __root unsigned char  Bus_SendLength=146;      //���߷��ͳ��ȣ���ע��ģʽʱ����Ϊ

//==============================================================
  
    __root unsigned char    BUS_SendCnt = 0;                    //�ط�����
    

    __root const unsigned char BlankStr[28]="555555555555";
    __root const unsigned char DeviceSN[16]="SZFS20250120001";
    __root const unsigned char DeviceAddr[10]={0x31,0x08};
    __root const unsigned char *Addrp=0; 
  
  
  
  
  
  
void SysVar_Init(void);
void BUS_RevData(void);
void GPIO_KEY_Tick(void);
void BUS_Rev_Tick(void);
void BUS_SendData(unsigned char Length);
void GPIO_MIC_SW(unsigned char status);
//============================================

#ifdef RxTestDebug
unsigned long rxtestDebugcnt=0;
#endif

//==============================================================
  void SysVar_Init(void)
  {
      
      Addrp=DeviceAddr;
      RunMode=0;
      Ledswitch=2;
  }
//==============================================================
  void STM8_Init(void)
  {
      CLK_CKDIVR    =0x18;        //16M/8=2M
  }
//==============================================================
void GPIO_EXTI_Init(void)
{
    EXTI_CR1_PCIS=1;            //PC��Ϊ�½����ж�
    
    PC_DDR_DDR7=0;
    PC_CR1_C17=1;
    PC_CR2_C27=1; 
}
void TIM2_Init(void)
{
    TIM2_IER  = 0x00;           //��ֹ�ж�
    TIM2_PSCR = 0x04;          //����Ԥ��Ƶ�Ĵ�����
                               
    TIM2_ARRH =0xFF;
    TIM2_ARRL =0xFF;
    
    TIM2_CNTRH=0x00;            //��ֵ
    TIM2_CNTRL=0x00;
    TIM2_CR1 |= 0x01;           //������ʱ��
}
void GPIO_KEY_Init(void)
{
    //==============================================
    PA_DDR_DDR1=0;
    PA_DDR_DDR2=0;    
    PA_CR1_C11=1;
    PA_CR1_C12=1;    
    PA_CR2_C21=0;               
    PA_CR2_C22=0;    
    //==============================================
    
    //==============================================
    PD_DDR_DDR4=0;        // 配置为输入
    PD_CR1_C14=1;         // 上拉输入
    PD_CR2_C24=0;         // 禁用外部中断

    //==============================================
     
    
    KEY0=0;
    KEY1=0;
    BUS_SendCnt =0;
}
void GPIO_LED_Init(void)
{
    PD_DDR_DDR3   =1;           //配置为输出
    PD_CR1_C13    =1;           //推挽输出模式
    PD_ODR_ODR3   =1;           //输出高电平，LED亮  
    
    Ledswitch=2;                 // 初始化时LED常亮
}
void TIM4_1ms_Init(void)
{
  TIM4_PSCR = 0x03;         //����Ԥ��Ƶ�Ĵ�����
                            //��8�ַ�Ƶ����1(0)��2(1)��4(2)��8(3)��16(4)��32(5)��64(6)��128(7)
  TIM4_ARR = 0xF9;         //�����Զ���װ�ؼĴ���
  
  TIM4_IER = 0x01;         //����TIM4�����¼��ж�ʹ��
  TIM4_CNTR = 0xF9;        //����TIM4��ʱ����ֵ��ʹ�ÿ�ʼ����ʱ������һ�����
  
  TIM4_CR1_CEN= 0x01;      //ʹ�ܼ���������TIM4_CR1�Ĵ���CENλΪ��1��
}
void TIM1_PWM_Init(void)
{
    PC_DDR_DDR4 =1;     
    //=============================================
    TIM1_PSCRH  =0;
    TIM1_PSCRL  =0;                     //��ʱ��1 ʱ�Ӳ���Ƶ
    
    TIM1_ARRH   =0;
    TIM1_ARRL   =19;                    //��ʱ��1��PWM���Ƶ�ʣ�2000 000/20=100K
    
    TIM1_CR1    &=0x8F;                 //���ϼ��������ض���ģʽ
    //=============================================
    TIM1_CCR4H  =0;
    TIM1_CCR4L  =10;
    TIM1_CCMR4  =0x60;                  //����CH4ΪPWMģʽ1
    TIM1_CCER2  &=0x1F;                //����CH4�ߵ�ƽ��Ч
    //TIM1_CCER2  |=0x10;                //ʹ��CH4���
    TIM1_OISR   &=0xBF;                //��������͵�ƽ
    //ͨ��4��100K_50% PWM���
    //=============================================
    TIM1_CR1    |=0x01;
    TIM1_BKR    =0x80;

}



void TIM2_PWM_Init(void)
{
   // TIM2_IER  = 0x04; 
  //  PD_DDR_DDR3 =1;     
    //=============================================

   
        
    TIM2_CCMR2  = TIM2_CCMR2 | 0x70;                  //����CH2ΪPWMģʽ1
  //  TIM2_CCER1  &=0x1F;                //����CH2�ߵ�ƽ��Ч
    TIM2_CCER1 = TIM2_CCER1 | 0x30;                //ʹ��CH2���
    
    TIM2_ARRH   =0;
    TIM2_ARRL   = 19;                    //��ʱ��1��PWM���Ƶ�ʣ�2000 000/100=20K
    
   // TIM2_CR1    &=0x8F;                 //���ϼ��������ض���ģʽ
    //=============================================
    TIM2_CCR2H  =0x0;
    TIM2_CCR2L  =0x00;

        TIM2_PSCR  =0;  //0x03
   // TIM2_OISR   &=0xBF;                //��������͵�ƽ
    //ͨ��2��1K_50% PWM���
    //=============================================
    TIM2_CR1   = TIM2_CR1 |0x01;
  //  TIM2_BKR    =0x80;

}

void GPIO_LED_Tick(void)
{
  static unsigned long flashTime=0;
    static unsigned char ledflag=0;
   static unsigned char ledflagbak=0;
#ifdef tim2Led
    
  if(Ledswitch==1)
  {
      //PD_ODR_ODR3=1;
      TIM2_CCR2H  =0;
      TIM2_CCR2L  =19;
      ledflag =0;
  }
  else if (Ledswitch==2)
  {
     if(LocalTime>flashTime)
      {
          flashTime=LocalTime+100;
          ledflag ++;
         
      }
     if (ledflagbak == ledflag ) {
        return;
       
     }
      ledflagbak = ledflag ;
      if(ledflag >39 ) {
           ledflag =0;
       }
         TIM2_CCR2H  =0x0;
     if (ledflag > 19 ) {
         TIM2_CCR2L  = (ledflag-19) ;
     } else  if (ledflag > 15 ) {
          TIM2_CCR2L  = (19-ledflag) ;
          ledflag = 20;
     }
     else {
        TIM2_CCR2L  = (19-ledflag) ;
     }
     
  }
  else
  {
      TIM2_CCR2H  =0x0;
      TIM2_CCR2L  =0x0;
       ledflag =0;
     // PD_ODR_ODR3=0;
  }
#else
  
  if(Ledswitch==1)
  {
      PD_ODR_ODR3=1;
   
  }
  else if (Ledswitch==2)
  {
    PD_ODR_ODR3=1;
  }
  else
  {
    PD_ODR_ODR3=0;
  }

  
  
  
#endif
}

void GPIO_KEY_Tick(void)
{
    static unsigned long keyTime1=0;
    static unsigned char keyResTime2 =0;
    static unsigned long key_timeout = 0;

    // KEY0（紧急按钮）处理
    if(PA_IDR_IDR1==1)          // 没有按下
    {
        keyTime1=LocalTime+120;  // 重置延时
    }
    else if(LocalTime>keyTime1)  // 按下且延时到
    {
        if(KEY0 == 0)           // 未处理状态
        {
            KEY0 = 2;           // 设置触发状态
            key_timeout = LocalTime + 100;
        }
    }

    // KEY1（取消按钮）处理
    if(PD_IDR_IDR4==0)          // 按下
    {
        if(keyResTime2 < 50)    // 消抖
        {
            keyResTime2++;
            if(keyResTime2 >= 50 && KEY1 == 0)
            {
                KEY1 = 2;       // 设置触发状态
            }
        }
    }
    else                        // 松开
    {
        keyResTime2 = 0;       // 重置消抖计数
    }
}
void BUS_RevData(void)
{
  //=======================================
     if(((BUS_Rev_Cmd[0]!=Addrp[0])||(BUS_Rev_Cmd[1]!=Addrp[1]))&&(BUS_Rev_Cmd[2]!=0x0E))
     {
        if((BUS_Rev_Cmd[0]!=0xFF)||(BUS_Rev_Cmd[1]!=0xFF))
          return;
     }
 
  //=======================================
   switch(BUS_Rev_Cmd[2])
   {
       case 0:
          break;
       case 1:
          break;
       case 2:
          break;
       case 3:
          break;
       case 4:                           
          break;
       case 5:                          
          break;
       case 6:                                
          break;
       case 7:                          // 取消命令
          Ledswitch=0;                  // 收到取消命令时关闭LED
          KEY0 = 0;                     // 重置紧急按钮状态
          break;
       case 8:                          
          break;
       case 9:                          // 切换到工作模式
          RunMode=1;                    // 设置为工作模式
          BUS_SendCnt=0;               // 重置发送计数
          Bus_SendLength=26;           // 设置发送长度
          break;
       case 13:                        
          BUS_SendCmd[0]=Addrp[0];
          BUS_SendCmd[1]=Addrp[1];
          BUS_SendCmd[2]=0x0D; 
          BUS_SendData(3); 
          break;
        case 14:
          if(BUS_Rev_Cmd[1]=='Y')      
          {
              RunMode=1; 
              Bus_SendLength=26;       
          }
          else
          {
              RunMode=0;                
              Bus_SendLength=146;                 
          }
          break;
   }
    Bus_RevFlag=0xFF;
}
void BUS_Rev_Tick(void)
{
      static unsigned char i=0,j=0,k=0;
      if(BUS_RevIndex==26)
      {
        BUS_Rev_Cmd[0]=0;
        BUS_Rev_Cmd[1]=0;
        BUS_Rev_Cmd[2]=0;
        for(k=0;k<24;k++)
        {
          i=k / 8;
          j=k % 8;
          if ((BUS_RevBuf[k]>280)&&(BUS_RevBuf[k]<400))
          {
            BUS_Rev_Cmd[i]|=(1<<j);
          }
        }
        BUS_RevIndex=0;
        i=(BUS_Rev_Cmd[0]+ BUS_Rev_Cmd[1]+(BUS_Rev_Cmd[2]&0x0F))&0x0F;
        j=(BUS_Rev_Cmd[2]>>4)&0x0F;
  
#ifdef RxTestDebug
        if(i==j)  
        {
          BUS_Rev_Cmd[2]=BUS_Rev_Cmd[2]&0x0F;
          BUS_RevData();  
        } else {
            rxtestDebugcnt ++;
             if (rxtestDebugcnt > 10) //200ms,100s
             {
               Ledswitch=1; 
            } 
          
        }
#else

          BUS_Rev_Cmd[2]=BUS_Rev_Cmd[2]&0x0F;
          BUS_RevData();  
    #endif
        
        
        
      }
}
//===================TIM4������������¼��ж���Ӧ����======================
#pragma vector=0x19            
__interrupt void TIM4_UPD_OVF_IRQHandler(void)
{
      __root static unsigned char flag=0;
      unsigned char i,j;
      
      TIM4_SR = 0;              //��������¼��жϱ�־λUIF
      LocalTime++;
    //  if(BUS_RevOverTime>0)BUS_RevOverTime--;
      //===================================
      if(flag>1)
      {
           TIM1_CCER2_CC4E=1;                           //GPIOA->BSRR = GPIO_Pin_9;           //����Ϊ�͵�ƽ
           flag--;
           return;    
      }
      else if(flag==1)
      {
           TIM1_CCER2_CC4E=0;                           //GPIOA->BRR = GPIO_Pin_9;            //����Ϊ�ߵ�ƽ
           flag=0;
           return;             
      }
      //===================================
      if((BUS_SendInex>0)&&(flag==0))
      {      
           if(BUS_SendInex==1)                          //��ʼλ������5ms�͵�ƽ
           {
               flag=5;
               TIM1_CCER2_CC4E=1;                       //GPIOA->BSRR = GPIO_Pin_9;
               BUS_SendInex++;
           }
           else if(BUS_SendInex<Bus_SendLength)
           {
               i=(BUS_SendInex-2)/8;
               j=(BUS_SendInex-2)%8;
               if(((BUS_SendingCmd[i]>>j)&0x01)>0)     //����λ1��2ms�͵�ƽ 
               {
                   flag=2;   
               }
               else                                    //����λ0��1ms�͵�ƽ
               {
                   flag=1;
               }
               TIM1_CCER2_CC4E=1;                       //GPIOA->BSRR = GPIO_Pin_9;
               BUS_SendInex++;
           }
           else if(BUS_SendInex==Bus_SendLength)
           {
               flag=0; 
               TIM1_CCER2_CC4E=1;                       //GPIOA->BSRR = GPIO_Pin_9;
               BUS_SendInex++;         
           }
           else
           {
               TIM1_CCER2_CC4E=0; 
               BUS_SendInex=0;
               flag=0;
          }
      }     
      
}
//===================�ⲿIO�½����ж��¼��ж���Ӧ����=====================
#pragma vector=0x07           
__interrupt void EXTI_PORTC_IRQHandler(void)
{
     unsigned int i=0;
      //===========================================
      i=TIM2_CNTRH;
      i=(i<<8)+TIM2_CNTRL;
      //===========================================
      if(BUS_RevIndex==0)
      {
           //===========================================
        //   BUS_RevOverTime=200;         //����200ms��ʱ
           Bus_RevFlag=0;              //������ձ�־λ
           //===========================================
           if((i>400)&&(i<750))
           {
              BUS_RevIndex=2;
              
           }
           else
           {
              BUS_RevIndex=0;
           }
      }
      else if(BUS_RevIndex==1)
      {
           if((i>400)&&(i<750))
           {
              BUS_RevIndex=2;
           }
           else
           {
              BUS_RevIndex=0;
           }
      }
      else if(BUS_RevIndex<26)
      {
            BUS_RevBuf[BUS_RevIndex-2]=i;
            BUS_RevIndex++;
      }
      //===========================================
      TIM2_CNTRH=0x00;            //��ֵ
      TIM2_CNTRL=0x00;
}


void BUS_SendData(unsigned char Length)
{
    unsigned char i=0,checksum=0;
    unsigned long timeout = LocalTime + 100;  // 100ms超时
    //======================================================
    checksum=0;
    BUS_SendCmd[Length-1]&=0x0F;
    for(i=0;i<Length;i++)
    {
        checksum+=BUS_SendCmd[i];
    }
    BUS_SendCmd[Length-1]|=((checksum&0x0F)<<4);
    //======================================================
    // 等待之前的发送完成，带超时保护
    while(BUS_SendInex>0)
    {
        if(LocalTime > timeout)
        {
            BUS_SendInex = 0;
            break;
        }
    }
    
    // 只有在确保之前的发送已完成时才开始新的发送
    if(BUS_SendInex == 0)
    {
        for(i=0;i<Length;i++)
        {
            BUS_SendingCmd[i]=BUS_SendCmd[i];
        }
        BUS_SendInex=1;
    }
}

void TestCancelButtonWithMessage(void)
{
    // 初始化 LED 引脚 (PD3)
    PD_DDR_DDR3 = 1;    // 配置为输出
    PD_CR1_C13 = 1;     // 推挽输出
    PD_ODR_ODR3 = 1;    // 初始状态LED点亮
   
    // 初始化变量
    static unsigned long LedOnTime = 0;    // LED开启时间记录
    
    // 初始化取消按键引脚 (PD4)
    PD_DDR_DDR4 = 0;    // 配置为输入
    PD_CR1_C14 = 1;     // 上拉输入
    PD_CR2_C24 = 0;     // 禁用外部中断

    // 初始化通信相关变量
    BUS_SendInex = 0;
    unsigned char debounceCount = 0;
    unsigned char buttonState = 0;
    unsigned char messageSent = 0;
    unsigned int i;

    // 初始化时钟
    CLK_CKDIVR = 0x18;        // 16M/8=2M
    
    // 初始化定时器4（用于LocalTime计数）
    TIM4_PSCR = 0x03;         // 8分频
    TIM4_ARR = 0xF9;          // 自动重装载值
    TIM4_IER = 0x01;          // 使能更新中断
    TIM4_CNTR = 0xF9;         // 计数器初值
    TIM4_CR1_CEN = 0x01;      // 使能计数器
    
    // 初始化通信相关
    TIM1_PWM_Init();          // 初始化PWM用于通信
    
    // 使能中断
    asm("rim");

    while(1)
    {
        if(PD_IDR_IDR4 == 0)  // 按键按下（低电平有效）
        {
            if(debounceCount < 50)  // 消抖计数
            {
                debounceCount++;
                for(i=0; i<100; i++) // 简单延时
                {
                    __asm("nop");
                }
                
                if(debounceCount >= 50 && !messageSent)  // 消抖完成且消息未发送
                {
                    // 1. 立即关闭LED
                    PD_ODR_ODR3 = 0;
                    
                    // 2. 准备发送取消消息
                    BUS_SendCmd[0] = 0x31;  // DeviceAddr[0]
                    BUS_SendCmd[1] = 0x08;  // DeviceAddr[1]
                    BUS_SendCmd[2] = 0x07;  // 取消命令
                    
                    // 3. 发送消息
                    BUS_SendData(3);
                    
                    buttonState = 1;    // 记录按键已按下
                    messageSent = 1;    // 标记消息已发送
                }
            }
        }
        else  // 按键松开
        {
            debounceCount = 0;
            if(buttonState == 1)  // 如果之前按键是按下状态
            {
                buttonState = 0;   // 清除按键状态
                messageSent = 0;   // 重置消息发送标志
            }
        }

        // 处理取消按键
        if(KEY1==2)             // 取消按键被按下且消抖完成
        {
            static unsigned long cancel_timeout = 0;
            // 1. 先执行本地操作
            Ledswitch = 0;      // 立即关闭LED
            KEY1 = 1;           // 设置为等待发送状态
            
            // 2. 等待通信就绪并发送取消命令
            if(BUS_SendInex == 0)
            {
                BUS_SendCmd[0]=Addrp[0];
                BUS_SendCmd[1]=Addrp[1];
                BUS_SendCmd[2]=0x07; 
                BUS_SendData(3);
                
                // 3. 只有在成功发送后才重置状态
                KEY1 = 0;           // 重置按键状态
                BUS_SendCnt = 0;    // 清除发送计数
                cancel_timeout = 0;  // 重置超时计数器
            }
            else
            {
                // 强制重置发送状态如果等待太久
                if(cancel_timeout == 0)
                {
                    cancel_timeout = LocalTime + 50; // 50ms超时
                }
                else if(LocalTime > cancel_timeout)
                {
                    BUS_SendInex = 0;  // 强制重置发送状态
                    cancel_timeout = 0; // 重置超时计数器
                }
            }
        }

        // 检查LED是否需要关闭（15秒后）
        if(Ledswitch == 2)
        {
            if((LocalTime - LedOnTime) >= 15000)  // 15秒 = 15000ms
            {
                Ledswitch = 0;  // 关闭LED
            }
        }
    }
}

int main(void)
{
   static unsigned long KeySentTime=0;
   static unsigned long LedOnTime=0;    // LED开启时间记录
   static unsigned char lastLedState = 0; // 记录LED上一次的状态
   unsigned char i;
   unsigned long TurnOnDelay=3600000;
   unsigned char TurnOnMode=0;
   //========================================================
   STM8_Init();
   GPIO_EXTI_Init();
   #ifndef   tim2Led
   TIM2_Init();
   #endif
   GPIO_LED_Init();
   TIM4_1ms_Init();
   GPIO_KEY_Init();
   TIM1_PWM_Init();
   #ifdef   tim2Led
   TIM2_PWM_Init();
   #endif

   SysVar_Init();
   
   //========================================================
   asm("rim");                   // 开启中断
   while(1)
   {
       //====================================================         
       BUS_Rev_Tick();
       GPIO_LED_Tick();
       GPIO_KEY_Tick();
       //===================================================
       if(RunMode==0)           // 注册模式
       {
           // 保持LED常亮，直到收到命令9
           if(Ledswitch != 2)
           {
               Ledswitch = 2;
           }
           
           // 处理按键等其他逻辑
           if(KEY0==2)          // 按键触发，发送注册信息
           {
               if(BUS_SendInex == 0)  // 通信空闲
               {
                   BUS_SendCmd[0]=Addrp[0];
                   BUS_SendCmd[1]=Addrp[1]; 
                   for(i=0;i<15;i++)
                   {
                       BUS_SendCmd[2+i]=DeviceSN[i];
                   }
                   BUS_SendCmd[17]=0x0E;
                   BUS_SendData(18);
                   KEY0 = 1;        // 设置为等待确认状态
               }
           }
       }
       else
       {
           // 处理紧急按键
           if(KEY0==2)              // 按键触发
           {
               // 立即设置LED状态（无论通信状态如何）
               if(Ledswitch != 2)
               {
                   Ledswitch = 2;
                   LedOnTime = LocalTime;
               }
               
               // 尝试发送命令
               if(BUS_SendInex == 0)  // 通信空闲
               {
                   // 发送紧急命令
                   BUS_SendCmd[0]=Addrp[0];
                   BUS_SendCmd[1]=Addrp[1];
                   BUS_SendCmd[2]=0x0C;
                   BUS_SendData(3);
                   KEY0 = 1;            // 设置为等待确认状态
               }
           }
           else if(KEY0 == 1)      // 等待确认状态
           {
               if(BUS_SendInex == 0)  // 如果发送完成
               {
                   KEY0 = 2;  // 继续保持触发状态，让LED持续亮
               }
           }
           
           // 处理取消按键
           if(KEY1==2)             // 取消按键触发
           {
               static unsigned long cancel_timeout = 0;
               
               // 立即关闭LED
               Ledswitch = 0;
               KEY0 = 0;       // 同时重置紧急按钮状态
               
               if(BUS_SendInex == 0)  // 通信空闲
               {
                   // 发送取消命令
                   BUS_SendCmd[0]=Addrp[0];
                   BUS_SendCmd[1]=Addrp[1];
                   BUS_SendCmd[2]=0x07;
                   BUS_SendData(3);
                   KEY1 = 0;       // 重置按键状态
               }
               else
               {
                   if(cancel_timeout == 0)
                   {
                       cancel_timeout = LocalTime + 50; // 50ms超时
                   }
                   else if(LocalTime > cancel_timeout)
                   {
                       BUS_SendInex = 0;  // 强制重置发送状态
                       cancel_timeout = 0; // 重置超时计数器
                   }
               }
           }
           
           // LED 15秒自动关闭
           if(Ledswitch == 2 && (LocalTime - LedOnTime) >= 15000)
           {
               Ledswitch = 0;      // 关闭LED
               KEY0 = 0;           // 重置按键状态
           }
       }
   }
   return 0;
}