搜索
bottom↓
回复: 5

分享一个已投入使用带预约定时功能的电紫砂煲程序,很方便

[复制链接]

出0入0汤圆

发表于 2012-12-30 18:53:52 | 显示全部楼层 |阅读模式

工程文件 :
前段时间给电紫砂煲做的一个带预约定时功能的控制器,用51做的 , 程序部分是从前辈那copy的,编的有点乱,如果有哪位高手能给优化一下将不胜感激.


/******************************************************************/
/*  用2片74 595 驱动8位LED显示   按键使用中断实现短按长按和连续   */
/*  因此操作按键时不影响程序的运行                                */
/*                                                                                */
/*                                                                                  */
/******************************************************************/

/******************************************************************/
/*            预处理宏定义                                        */
/******************************************************************/
        #include <REG52.h>
        #include <math.h>
        #include <INTRINS.H>
        #include <string.h>

        typedef  unsigned int  uint;           //无符号整型
        typedef  unsigned int  UINT;
        typedef  unsigned long  ulong;           //无符号长整型
        typedef  unsigned long  ULONG;
        typedef  unsigned char  uchar;           //无符号字符型
        typedef  unsigned char  UCHAR;

        /* 按键键值宏定义 */
        #define    KEY_VALUE1    0x0E           //按键1按下
        #define    KEY_VALUE2    0x0D
        #define    KEY_VALUE3    0x0B
        #define    KEY_VALUE4    0x07
        #define    KEY_NULL      0xFF      //无按键按下
        uint KeyValue = KEY_NULL ;

        /* 按键状态宏定义 */
        #define    INIT_STATE    0                   //初始化状态
        #define           SHAKE_STATE   1                   //按键抖动状态
        #define    PRESS_STATE   2         //按键按下状态
        #define    LONG_STATE    3         //按键长按状态
        #define    CONTINUE_STATE    4     //按键连续状态
        #define    RELEASE_STATE     5     //按键释放状态

    /* 按键返回值状态宏定义 */
        #define    KEY_DOWN       0x80           //按下
        #define    KEY_LONG        0x40           //长按
        #define    KEY_CONTINUE    0x20           //连按
        #define    KEY_UP     0x10           //释放

        /* 定义长按键的TICK数,以及连按间隔的TICK数*/
        #define KEY_LONG_PERIOD 100             //长按时间基数
        #define KEY_CONTINUE_PERIOD 25            //连按时间基数
        uint KeyDelay=0;  // key 按下延时


        /* 定义数码管显示位*/
        #define        wei1   0xfe
        #define        wei2   0xfd
    #define        wei3   0xfb
        #define        wei4   0xf7
        #define        wei5   0xef
        #define        wei6   0xdf
        #define        wei7   0xbf
        #define        wei8   0x7f  
        #define        wei_all   0xf0


/******************************************************************/
/*            I/O定义                                            */
/******************************************************************/       
        /* 锁存使能 */
        //sbit  DM = P1^4;               //数码管段码锁存使能
        //sbit  WM = P1^5;                  //数码管位码锁存使能
        //sbit  LED = P1^6;                  //LED锁存使能
        //sbit  MOTOR = P3^7;           //电机锁存使能
        //sbit  MOTOR1 = P3^6;           //电机锁存使能

        /* 继电器输出 */
        sbit  HighTmp=P0^7;      //高温继电器
        sbit  LowTmp=P0^5;                //低温继电器
        sbit  AutoTmp=P0^6;                //自动温度继电器
        //sbit  ledtest=P1^5;       
        sbit  Beep=P2^7;       //蜂鸣器

        /* 功能指示Led */
        sbit  Func_Led1=P0^0;      //功能1指示
        sbit  Func_Led2=P0^1;                //功能2指示
        sbit  Func_Led3=P0^2;                //功能3指示
        sbit  TimeOn_Led=P1^6;                //预约指示
        sbit  TimeOff_Led=P1^7;                //定时指示

        /* 数码管显示595 2片 */
        sbit SCLK_595 =P2^0; //移位时钟脉冲
        sbit SDATA_595=P2^2; //串行数据输入
        sbit RCK_595 =P2^1; //输出锁存器控制脉冲

        /* 独立按键 */
        sbit  KEY1 = P2^3;                  //独立按键1
        sbit  KEY2 = P2^4;                  //独立按键2
        sbit  KEY3 = P2^5;                  //独立按键3
        sbit  KEY4 = P2^6;                  //独立按键4

/******************************************************************/
/*                    变量定义开始                                    */
/******************************************************************/

        /* 定义定时中断变量*/
        bit  bTime20mS = 0;     //20ms中断标志位
        bit  fTime1S = 0;          //2s中断标志位
        bit Flag_5s_Start=0;
        bit Flag_5s_End=0;
        uint cnt_5s=0;       
        bit Flag_1s_Start=0;       
        uint cnt_1s=0;
        uint cnt_Beepshort=0;
        bit Beepshort=0;
        bit Beeplong=0;
        uint cnt_Beeplong=0;
        uint flash_1s=0;       
        uchar FlagFunc=0; //定义功能标识
        uchar FlagTimeOn=0; //定义预约标识
        uchar FlagTimeOff=0; //定义定时标识
        bit FuncStart=0;   //功能启动标识
        bit TimeOnStart=0; //预约启动标识
        bit TimeOffStart=0; //定时启动标识       
        uchar h,m,s;
        uint x=0 ;
        int ii=0;

        /* 定义数据传输存储数组*/  
        #define        Address   0x02   //定从站站址为 2
        uchar DataBuf[32]={0x02,0x00,0x00,0x00,0x00,00,00,10,03,30,30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};          //  0站址  1命令  2功能 3状态 4预约 5预约时 6预约分 7定时 8定时时 9定时分 10取消
                                   //         0    1          2    3    4   5   6  7   8    9    10   11   12   13   14   15   16   17   18   19

        /* 定义数码管显示变量*/
        uint Disp_temp;       
        uchar code DAT[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x76,0x73,0x3e,0x00,0x40,0x63};         
                                        //         0 ,  1 , 2    3    4     5    6    7    8     9          A    b    C    d    E    F  (16)H        P     U    空   -         °C   
                                        //以下为7段共阴LED数码管段码表
                                        //    0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,         /*共阴7段LED段码表*/
                                        //    0x77,0x7c,0x39,0x5e,0x79,0x71,0x76,0x73,0x3e,0x00};

/******************************************************************/
/*                   函数声明2                                    */
/******************************************************************/
        void  KeyInit(void);
        void  GetKey(uint *pKeyValue);
        void  WR_595(void);
        void  OUT_595(void);
        void  Disp_Out(uchar wei,uchar shu);
        void  LedOnOff(void);
        void  TimerInit(void);
        void  KeyChuli(void);
        void  FunChuli(void); //功能处理
        void  Display(void); //显示函数

/******************************************************************/
/*                   按键初始化函数                               */
/******************************************************************/
        void  KeyInit(void)
        {
                KEY1 = 1;
                KEY2 = 1;
                KEY3 = 1;
                KEY4 = 1;
        }       
/******************************************************************/
/*                   底层按键扫描函数                             */
/******************************************************************/
        uint  KeyScan(void)
        {
                if(KEY1 == 0)
                {
                        return KEY_VALUE1;                           //0x0e
                }
                else if(KEY2 == 0)
                {
                        return KEY_VALUE2;
                }
                else if(KEY3 == 0)
                {
                        return KEY_VALUE3;
                }
                else if(KEY4 == 0)
                {
                        return KEY_VALUE4;
                }
                else
                {
                        return KEY_NULL;
                }
        }
/******************************************************************/
/*                   获取按键值函数                               */
/******************************************************************/
        void  GetKey(uint *pKeyValue)
        {
                static  uint  sKeyState = INIT_STATE;          //设按键状态为 初始化状态 0
                static  uint  sTimeCount = 0;
                static  uint  sLastKey = KEY_NULL;                   //保存按键释放时候的键值
                uint  KeyTemp = KEY_NULL;                  
       
                if(bTime20mS)                //20mS扫描一次 中断一次
                {
                        bTime20mS = 0;       
                        KeyTemp = KeyScan();                // 底层按键扫描函数  返回时哪个按键按下
       
                        switch(sKeyState)                 //根据按键状态选择
                        {
                                case  INIT_STATE:           //如果为初始状态 0
                                {
                                        if(KeyTemp != KEY_NULL)          // 如果有按键按下
                                        {
                                                sKeyState = SHAKE_STATE;  //消抖  返回1
                                        }       
                                }
                                break;
       
                                case  SHAKE_STATE:                 //消抖 1
                                {
                                        if(KeyTemp != KEY_NULL)            // 如果有按键按下
                                        {
                                                sKeyState = PRESS_STATE;     //返回2 按键为按下状态
                                        }       
                                }
                                break;
       
                                case  PRESS_STATE:                  //如果为按下状态 2
                                {
                                        if(KeyTemp != KEY_NULL)
                                        {                               
                                                sLastKey = KeyTemp ;  //保存键值,以便在释放按键状态返回键值
                                                KeyTemp |= KEY_DOWN ;        //按键按下
                                                sKeyState = LONG_STATE;             //赋值为长按状态                                               
                                        }
                                        else
                                        {
                                                sKeyState = INIT_STATE;
                                        }
                                }
                                break;
       
                                case  LONG_STATE:           //如果为长按状态
                                {
                                        if(KeyTemp != KEY_NULL)
                                        {
                                                if(++sTimeCount > KEY_LONG_PERIOD)    //长按时间计数
                                                {
                                                        sTimeCount = 0;                                               
                                                        KeyTemp |= KEY_LONG ;         //长按键事件发生
                                                        sKeyState = CONTINUE_STATE;                  //4  连续按下
                                                }       
                                        }
                                        else
                                        {
                                                sKeyState = RELEASE_STATE;
                                        }
                                }
                                break;
       
                                case  CONTINUE_STATE:                //连续按下状态
                                {
                                        if(KeyTemp != KEY_NULL)
                                        {
                                                if(++sTimeCount > KEY_CONTINUE_PERIOD)        //连按时间计数
                                                {
                                                        sTimeCount = 0;
                                                        KeyTemp |= KEY_CONTINUE ;        //赋值为连续按下
                                                }
                                        }
                                        else
                                        {
                                                sKeyState = RELEASE_STATE;          //5
                                        }
                                }
                                break;
       
                                case  RELEASE_STATE:                 //释放状态 5
                                {
                                        sLastKey |= KEY_UP ;
                                        KeyTemp = sLastKey ;       
                                        sKeyState = INIT_STATE;                                               
                                }
                                break;
                       
                        }                       
                }
                *pKeyValue = KeyTemp ;            //返回按键值和按键状态       
        }
/******************************************************************/
/*                   写595寄存器函数                              */
/******************************************************************/               
        void WR_595(void)        //将显示数据送入74HC595内部移位寄存器
        {
                uchar j;
                for (j=0;j<16;j++)
                {
                        Disp_temp=Disp_temp<<1;
                        SDATA_595=CY;
                        SCLK_595=1; //上升沿发生移位
        //                _nop_();_nop_();
                        SCLK_595=0;
                }
        }
/******************************************************************/
/*                   595寄存器输出函数                            */
/******************************************************************/
        void OUT_595(void)                 //将移位寄存器内的数据锁存到输出寄存器并显示
        {
                RCK_595=0;
        //        _nop_();_nop_();
                RCK_595=1;                 //上升沿将数据送到输出锁存器
        //        _nop_();_nop_(); _nop_();
                RCK_595=0;
        }
/******************************************************************/
/*                   数码管显示函数                              */
/******************************************************************/
        void Disp_Out(uchar wei,uchar shu)         //接收数据并显示到数码管上
        {
        Disp_temp= (wei<<8)+ DAT[ shu ] ;
        WR_595();
        OUT_595();  
        }

/******************************************************************/
/*                   指示灯亮灭闪烁函数                              */
/******************************************************************/
        void LedOnOff(void)
        {
                /******功能指示灯开始*****/
                if(FlagFunc==0)
                {
                 Func_Led1 = 1 ;
                 Func_Led2 = 1 ;
                 Func_Led3 = 1 ;
                }
                if(FlagFunc==1&&FuncStart==0)
                {
                 Func_Led1 = ~Func_Led1 ;
                 Func_Led2 = 1 ;
                 Func_Led3 = 1 ;
                }
                else if(FlagFunc==1&&FuncStart==1)
                {
                 Func_Led1 = 0 ;
                 Func_Led2 = 1 ;
                 Func_Led3 = 1 ;
                }
                if(FlagFunc==2&&FuncStart==0)
                {
                 Func_Led1 = 1 ;
                 Func_Led2 =  ~Func_Led2 ;
                 Func_Led3 = 1 ;
                }
                else if(FlagFunc==2&&FuncStart==1)
                {
                 Func_Led1 = 1 ;
                 Func_Led2 = 0 ;
                 Func_Led3 = 1 ;
                }
                if(FlagFunc==3&&FuncStart==0)       
                {
                 Func_Led1 = 1 ;
                 Func_Led2 = 1 ;
                 Func_Led3 = ~Func_Led3 ;
                }
                else if(FlagFunc==3&&FuncStart==1)
                {
                 Func_Led1 = 1 ;
                 Func_Led2 = 1 ;
                 Func_Led3 = 0 ;
                }
                /******预约指示灯开始*****/
                if( FlagTimeOn==0 )           // 预约指示灯灭初始化
                {
                 TimeOn_Led = 1 ;
                }
                if( FlagTimeOn==1 && TimeOnStart==0 )         //预约指示灯闪烁
                {
                 TimeOn_Led = ~TimeOn_Led ;
                }
                else if( FlagTimeOn==1 && TimeOnStart==1 )           //预约指示灯常亮
                {
                 TimeOn_Led = 0 ;
                }
            /******定时指示灯开始*****/
                if( FlagTimeOff==0 )           // 指示灯灭初始化
                {
                 TimeOff_Led = 1 ;
                }
                if( FlagTimeOff==1 && TimeOffStart==0 && FlagTimeOn==0 )         //指示灯闪烁
                {
                 TimeOff_Led = ~TimeOff_Led ;
                }
                else if( FlagTimeOff==1 && TimeOffStart==1 )           //指示灯常亮
                {
                 TimeOff_Led = 0 ;
                }                                            
        }

/******************************************************************/
/*                   定时器初始化函数                             */
/******************************************************************/                                       
        void  TimerInit(void)
        {
                TMOD &= 0xf0;      //定时器0 工作方式1 20ms中断一次
                TMOD |= 0x01;
                //TH0 = 0xB1;
                //TL0 = 0xE0;
                TH0 = 0xB8;
                TL0 = 0x19;
                TR0 = 1;
                ET0 = 1;
        }
/******************************************************************/
/*                   定时中断函数                                 */
/******************************************************************/
        void  Timer0(void) interrupt 1          // 定时器中断处理函数
        {
                TH0 = 0xB8;
                TL0 = 0x19;
                bTime20mS = 1;
                flash_1s ++;
                //MOTOR = ~MOTOR ;
                /******led闪烁开始*****/
            if(flash_1s>=25)          //功能选择时相应led闪烁
                  {
                    flash_1s=0;
                        LedOnOff();          //指示灯亮灭函数
                  }
                /******5s倒计时开始*****/
                if( Flag_5s_Start && ( ~Flag_5s_End ) )          //5秒倒计时
                {
                   cnt_5s++;
                   if(cnt_5s>=250)    //5s
                   {
                      cnt_5s = 0;
                          Flag_5s_End=1;
                   }
                }
                else
                {
                   cnt_5s=0;
                }
       
                /******1s定时开始*****/
                if(Flag_1s_Start)
                {
                   cnt_1s++;
                   if(cnt_1s==100)    //1s
                   {
                      cnt_1s=0;
                          Flag_1s_Start=0;
                   }
                }
                else
                {
                   cnt_1s=0;
                }
                /******蜂鸣器短响开始*****/
                if( Beepshort==1 )
                {
                   cnt_Beepshort++;
                   if(cnt_Beepshort==10) Beep=0;
                   if(cnt_Beepshort==20)    //1s
                   {
                      cnt_Beepshort=0;
                          Beep=1;
                          Beepshort=0;                     
                   }
                }
                else
                {
                   cnt_Beepshort=0;
                }
                /******蜂鸣器长响开始*****/
                if( Beeplong==1 )
                {
                   cnt_Beeplong++;
                   //Beep=0;
                   if(cnt_Beeplong%10==0)    //1s
                   {
                          Beep=~Beep;             
                   }
                   if(cnt_Beeplong%30==0)    //1s
                   {
                          Beep=~Beep;             
                   }

                   if(cnt_Beeplong==1260)    //1s
                   {
                      cnt_Beeplong=0;
                          Beep=1;
                          Beeplong=0;                     
                   }
                }
                else
                {
                   cnt_Beeplong=0;
                }               
                /*预约倒计时减及s基数定义处理 */
                if( TimeOnStart==1 )          //预约
                {
                        if( DataBuf[5]>0 || DataBuf[6]>0 || DataBuf[7]>0 )   // 判断是否需要减位
                        {       
                                x++;          //x=50 , 50*20ms=1s来实现计时单位为1s
                                if(x==50) //x=50 , 50*20ms=1s来实现计时单位为1s
                                {
                                        x=0 ;
                                        if(DataBuf[7]==0)
                                        {
                                                DataBuf[7]=59;
                                                if(DataBuf[6]==0)
                                                {
                                                        DataBuf[6]=59 ;
                                                        if(DataBuf[5]>0)
                                                        {
                                                                DataBuf[5]-- ;
                                                        }
                                                }
                                                else
                                                {
                                                        DataBuf[6]--;
                                                }               
                                        }
                                        else
                                        {
                                         DataBuf[7]-- ;
                                        }
                                }
                     }
                    }       
                /*定时倒计时减及s基数定义处理 */
                if( TimeOffStart==1 )          //定时
                {
                        if( DataBuf[8]>0 || DataBuf[9]>0 || DataBuf[10]>0 )   // 判断是否需要减位
                        {       
                                x++;          //x=50 , 50*20ms=1s来实现计时单位为1s
                                if(x==50) //x=50 , 50*20ms=1s来实现计时单位为1s
                                {
                                        x=0 ;
                                        if(DataBuf[10]==0)
                                        {
                                                DataBuf[10]=59;
                                                if(DataBuf[9]==0)
                                                {
                                                        DataBuf[9]=59 ;
                                                        if(DataBuf[8]>0)
                                                        {
                                                                DataBuf[8]-- ;
                                                        }
                                                }
                                                else
                                                {
                                                        DataBuf[9]--;
                                                }               
                                        }
                                        else
                                        {
                                         DataBuf[10]-- ;
                                        }
                                }
                     }
                  }                                   
        }
/******************************************************************/
/*                   按键处理函数                                 */
/******************************************************************/
        void  KeyChuli(void)
        {         
                KeyDelay ++;
                /****** 按键1 ********/
                if( KeyValue == (KEY_VALUE1 | KEY_DOWN) )                 //按键1按下0x0e|0x80 = 0x8e
                {
                        if(KeyDelay>300)
                        {       
                                if( FuncStart != 1 )
                                {
                                        if( FlagFunc>2 )
                                        {
                                         FlagFunc=0;
                                        }
                                        FlagFunc ++;
                                        KeyDelay=0;
                                        if( FlagFunc==1 )
                                        {
                                        DataBuf[5]=0;
                                        DataBuf[6]=0;
                                        DataBuf[7]=0;
                                        DataBuf[8]=2;
                                        DataBuf[9]=0;
                                        DataBuf[10]=0;
                                        //高温
                                        }
                                        if( FlagFunc==2 )
                                        {
                                        DataBuf[5]=8;
                                        DataBuf[6]=30;
                                        DataBuf[7]=0;
                                        DataBuf[8]=0;
                                        DataBuf[9]=30;
                                        DataBuf[10]=3;
                                        //自动
                                        }
                                        if( FlagFunc==3 )
                                        {
                                        DataBuf[5]=0;
                                        DataBuf[6]=0;
                                        DataBuf[7]=0;
                                        DataBuf[8]=5;
                                        DataBuf[9]=1;
                                        DataBuf[10]=0;
                                        //保温
                                        }
                                }               
                        }
                }
                else if( KeyValue == (KEY_VALUE1 | KEY_LONG) )                //按键1长按
                {

                }
                else if( KeyValue == (KEY_VALUE1 |KEY_CONTINUE) )                 //按键1连续
                {
                       
                }
                else if( KeyValue == (KEY_VALUE1 | KEY_UP) )                //按键1释放
                {
       
                }
                /******* 按键2 *******/
                if( KeyValue == (KEY_VALUE2 | KEY_DOWN) )                 //按键2按下0x0e|0x80 = 0x8e
                {                                                   
                        if(KeyDelay>300)
                        {
                                if( FlagFunc!=0 && FuncStart==0 && TimeOffStart==0 )
                                {
                                        Flag_1s_Start=0;
                                        if( FlagTimeOn==1 )
                                        {
                                         DataBuf[6]+=10 ;
                                        }
                                        FlagTimeOn=1;                        
                                }
                        }
                }
                else if( KeyValue == (KEY_VALUE2 | KEY_LONG) )                //按键2长按
                {

                }
                else if( KeyValue == (KEY_VALUE2 |KEY_CONTINUE) )                 //按键2连续
                {
                 
                 DataBuf[5]++ ;
                }
                else if( KeyValue == (KEY_VALUE2 | KEY_UP) )                //按键2释放
                {
       
                }
            /******* 按键3 *******/
                if( KeyValue == (KEY_VALUE3 | KEY_DOWN) )                 //按键3按下
                {
                         if(KeyDelay>300)
                        {
                                if( FlagFunc!=0 )
                                {
                                    Flag_1s_Start=1;
                                        if( FlagTimeOff==1 )
                                        {
                                         DataBuf[9]+=10 ;
                                        }
                                        FlagTimeOff=1;                        
                                }
                        }
               
                }
                else if( KeyValue == (KEY_VALUE3 | KEY_LONG) )                //按键3长按
                {
                 //DataBuf[8]++ ;                       
                }
                else if( KeyValue == (KEY_VALUE3 |KEY_CONTINUE) )                 //按键3连续
                {
                 DataBuf[8]++ ;       
                }
                else if( KeyValue == (KEY_VALUE3 | KEY_UP) )                //按键3释放
                {
               
                }
            /******** 按键4 ********/
                if( KeyValue == (KEY_VALUE4 | KEY_DOWN) )                 //按键4按下
                {
                         FlagFunc=0;
                         FuncStart=0;
                         FlagTimeOn=0;
                         TimeOnStart=0;
                         FlagTimeOff=0;
                         TimeOffStart=0;
                         Disp_Out(wei_all,0) ;
                         Beeplong=0;                               
                }
                else if( KeyValue == (KEY_VALUE4 | KEY_LONG) )                //按键4长按
                {
                                       
                }
                else if( KeyValue == (KEY_VALUE4 |KEY_CONTINUE) )                 //按键4连续
                {
               
                }
                else if( KeyValue == (KEY_VALUE4 | KEY_UP) )                //按键4释放
                {
               
                }
                /*******按键加预约时间处理部分*******/
                if( DataBuf[7]>=60 )
                {
                 DataBuf[7]=DataBuf[7]-60;
                 DataBuf[6]++;                 
                }
                   if( DataBuf[6]>=60 ) //如果
                {
                 DataBuf[6]=DataBuf[6]-60;
                 DataBuf[5]++;                 
                }
                if( DataBuf[5]>=12 )
                {
                 DataBuf[5]=0;
                }
                /*******按键加定时时间处理部分*******/
            if( DataBuf[10]>=60 )
                {
                 DataBuf[10]=DataBuf[10]-60;
                 DataBuf[9]++;                 
                }
                   if( DataBuf[9]>=60 ) //如果
                {
                 DataBuf[9]=DataBuf[9]-60;
                 DataBuf[8]++;                 
                }
                if( DataBuf[8]>=12 )
                {
                 DataBuf[8]=0;
                }
                  /*****按键蜂鸣程序*****/
                if( KeyValue != KEY_NULL ) //只要有按键按下
                {
                 Beepshort=1;
                }
        }
/******************************************************************/
/*                   功能处理函数                                 */
/******************************************************************/
        void  FunChuli(void)
        {
                if( FlagFunc!=0 ) //功能1时间赋初值
                {

                         if( FlagTimeOn==1 && Flag_1s_Start==0 )   //预约功能选择且无定时键按下  显示预约
                         {
                          h=DataBuf[5];
                         m=DataBuf[6];
                         s=DataBuf[7];
                         }       
                        if( FlagTimeOn==0 || Flag_1s_Start==1 )        //无预约或定时间按下 则显示定时
                        {
                         h=DataBuf[8];
                         m=DataBuf[9];
                         s=DataBuf[10];
                        }               
                }
                // 预约5s倒计时
                if( FlagFunc!=0 )
                {
                  Flag_5s_Start=1;
                }
                else
                {
                  Flag_5s_Start=0;
                }

                if( KeyValue != KEY_NULL ) //只要有按键按下5s倒计时就重新计时
                {
                 cnt_5s=0;
                 cnt_1s=0;
                }
                 /*****当只按下功能键5s后启动定时*****/
                 if( FlagFunc!=0 && Flag_5s_End==1 && FlagTimeOn==0 )  // 在直选功能模式中 当5秒倒计时结束时 启用
                 {
                        FlagTimeOff=1;           //启用定时倒计时
                        if( TimeOffStart==0 )Beepshort=1;
                 }
                 /*****预约倒计时5s后启动*****/
                 if( FlagTimeOn==1 && Flag_5s_End==1 )  // 在预约模式中 当5秒倒计时结束时 启用预约模式
                 {
                  if( TimeOnStart==0 )Beepshort=1;                          
                  TimeOnStart=1;
                  Flag_5s_End=0;
                 }
                 /*****定时倒计时5s后启动*****/
                 if( FlagTimeOff==1 && Flag_5s_End==1 )  // 在定时模式中 当5秒倒计时结束时 启用模式
                 {                  
                  TimeOffStart=1;
                  FuncStart=1;    //倒计时启动的同时 功能启动
                  Flag_5s_End=0;       
                 }
                /*****预约倒计时完成后启用定时倒计时*****/
                if( FlagFunc!=0 && FlagTimeOn==1 && TimeOnStart==1 )        //如果选择了功能,且选择了预约 而且预约已启动
                {
                        if( h==0 && m==0 && s==0 ) //如果预约倒计时完成,则启用功能
                        {
                           FlagTimeOn=0;   //预约标识复位
                         TimeOnStart=0;   //预约启动复位
                         FlagTimeOff=1;           //启用定时倒计时
                        }
                }
                /*****定时倒计时完成后关闭功能*****/
                if( FlagFunc!=0 && FlagTimeOff==1 && TimeOffStart==1 )        //如果选择了功能,且选择了定时
                {
                        if( h==0 && m==0 && s==0 ) //如果定时倒计时完成,则启用功能
                        {
                         FlagFunc=0;           //功能标识复位
                         FuncStart=0;           //功能复位
                         FlagTimeOff=0;           //定时倒计时标识复位
                         TimeOffStart=0;   //定时倒计时停止
                         Disp_Out(wei_all,20) ;
                         Beeplong=1;
                        }
                }

                /*****根据功能启动相应继电器*****/
                if( FuncStart==1 )
                { //if( FlagFunc==1) AutoTmp=0;
                 switch(FlagFunc)                 //根据功能状态选择
                        {
                                case  0:           //无功能 继电器无输出
                                {
                                 HighTmp=1;
                                 LowTmp=1;
                                 AutoTmp=1;       
                                }
                                break;
                                case  1:                 //功能1 高温
                                {
                                 HighTmp=0;
                                 LowTmp=0;
                                 AutoTmp=1;       
                                }
                                break;
                                case  2:                 //功能2 自动
                                {
                                 HighTmp=1;
                                 LowTmp=0;
                                 AutoTmp=0;       
                                }
                                break;
                                case  3:                 //功能3 保温
                                {
                                 HighTmp=1;
                                 LowTmp=0;
                                 AutoTmp=1;       
                                }
                                break;
                        }
                }
                else
                {
                        HighTmp=1;
                        LowTmp=1;
                        AutoTmp=1;       
                }
        }
/******************************************************************/
/*                   显示函数                                 */
/******************************************************************/
        void  Display(void)
        {

                /*****显示输出*****/
                if( FlagFunc!=0 )        //选择相应功能后才显示预约定时时间
                {
                       
                        Disp_Out(wei4,h/10) ;       
                        Disp_Out(wei3,h%10) ;
                        Disp_Out(wei2,m/10) ;
                        Disp_Out(wei1,m%10) ;
                        Disp_Out(wei6,s/10) ;
                        Disp_Out(wei5,s%10) ;

                        //Disp_Out(wei4,DataBuf[8]/10) ;       
                        //Disp_Out(wei3,DataBuf[8]%10) ;
                        //Disp_Out(wei2,DataBuf[9]/10) ;
                        //Disp_Out(wei1,DataBuf[9]%10) ;
                        //Disp_Out(0xbf,DataBuf[10]/10) ;
                        //Disp_Out(0x7f,DataBuf[10]%10) ;
                }
        }
/******************************************************************/
/*                   主函数                                       */
/******************************************************************/
void  Main(void)
{       
        Beep=1;                  //初始化蜂鸣器
        TimerInit();          /* 定时器初始化函数 */
        KeyInit();           /* 按键扫描初始化函数 */
        EA = 1;          //开总中断
        Disp_Out(wei_all,0) ;        //显示待机状态 00:00

        while(1)
        {       
                //Display(); //显示函数
                GetKey(&KeyValue);        //按键判断函数
                KeyChuli();           //按键处理函数
                FunChuli();          //功能处理函数
                Display(); //显示函数
         }       

}       

//************主函数结束*********************************//


本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x

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

知道什么是神吗?其实神本来也是人,只不过神做了人做不到的事情 所以才成了神。 (头文字D, 杜汶泽)

出0入4汤圆

发表于 2012-12-30 19:57:20 | 显示全部楼层
刚买了一个!

出0入0汤圆

 楼主| 发表于 2012-12-30 21:00:32 | 显示全部楼层
langbaiyue 发表于 2012-12-30 19:57
刚买了一个!

本来我也想买的 可是买便宜的不能联网啊, 没法只能自己做了 然后再连到电脑或互联网上,这一块还在做着, 这个通讯以及协议让人头疼

出0入0汤圆

发表于 2012-12-30 21:16:58 | 显示全部楼层
mark一下

出0入0汤圆

发表于 2013-1-1 21:31:44 | 显示全部楼层
不错哦,再贴原理图和实物图上来看看啦

出0入0汤圆

 楼主| 发表于 2013-1-2 12:20:10 | 显示全部楼层
本帖最后由 xingyuewang 于 2013-1-2 12:25 编辑
tonyone 发表于 2013-1-1 21:31
不错哦,再贴原理图和实物图上来看看啦


一开始做的那个外壳有点丑内部电路当时忘了拍照了 这样吧把我新作的一个图贴上来吧 功能差不多


本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片,浪费大家下载带宽和论坛服务器空间,请压缩后(图片小于1兆)才上传。压缩方法可以在微信里面发给自己(不要勾选“原图),然后下载,就能得到压缩后的图片。注意:要连续压缩2次才能满足要求!!】。另外,手机版只能上传图片,要上传附件需要切换到电脑版(不需要使用电脑,手机上切换到电脑版就行,页面底部)。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有:东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案:44190002001997 ) )

GMT+8, 2024-7-23 20:22

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表