开启辅助访问

amobbs.com 阿莫电子技术论坛

登录 注册 找回密码
搜索
amobbs.com 阿莫电子技术论坛»论坛首页 › 单片机 › 51单片机 › 大大们帮忙改改这个程序。
bottom↓
返回列表 发新帖
回复: 1

大大们帮忙改改这个程序。

[复制链接]
j9600953

出0入0汤圆
发表于 2013-8-10 22:42:30 | 显示全部楼层 |阅读模式
数码之家看到的帖子xingyuewang的帖子

定时预约程序，

先解释一下这个题目,这个开关只是智能家居系统的基础部分,联网部分还在调试中,协议使用的伪Modbus(说白了就是为了适合51精简的Modbus)。等其他东西调试好了稳定了我会陆续发上来。争取会DIY各位朋友家里都能用上智能系统。
这个开关是上个月做的一直用着比较稳定,程序是吸收了前辈的精华，再加上我拙劣的编程。有好的地方大家就借鉴借鉴，不好的地方大家就当看热闹了。
硬件软件简要： 1. stc15F204    20PIN
                          2. 4位共阳数码管
                          3.剩下的硬件大家还是看图吧 没多少东西
                          4.程序要点  段码使用不同IO的转换
                          5.程序要点 按键扫描使用中断实现,可以点击  连按   长按  这个是移植的前辈的 很好用
                          6.  3按键用了一个ADC引脚
                          7.剩下的自己研究程序去吧.

我复制了一个，单片机换成stc12c5a60s2 不知道程序怎么改写！大大们帮帮忙吧，看看有没有错误

/*------------------------------------------------------------------*/
/* --- STC MCU International Limited -------------------------------*/
/* --- STC 1T Series MCU Programme Demo ----------------------------*/
/* --- Fax: 86-755-82944243 ----------------------------------------*/
/* --- Tel: 86-755-82948412 ----------------------------------------*/
/* --- Web: [url] url] -----------------------------------------*/
/* If you want to use the program or the program referenced in the  */
/* article, please specify in which data and procedures from STC    */
/*------------------------------------------------------------------*/

/*      本程序经过测试完全正常, 不提供电话技术支持, 如不能理解, 请自行补充相关基础.  */


/*************        本程序功能说明        **************

P1.0做ADC输入，从串口输出结果(ASCII)，9600,8,N,1.

用户只需要更改 MAIN_Fosc 来适应自己的系统。

******************************************/


/*************        用户系统配置        **************/

#define MAIN_Fosc                12059200L        //定义主时钟, 模拟串口和和延时会自动适应。5~35MHZ

//#define T1MS (65536-MAIN_Fosc/1000)      //1T模式
//#define T1MS (65536-MAIN_Fosc/12/1000) //12T模式
#define T20MS (65536-MAIN_Fosc/50)      //1T模式
//#define T20MS (65536-MAIN_Fosc/12/50) //12T模式


/*************        以下宏定义用户请勿修改        **************/
#include        "reg51.H"
#define        uchar        unsigned char
#define uint        unsigned int
/******************************************/

sfr P1ASF     = 0x9D;        //12C5A60AD/S2系列模拟输入(AD或LVD)选择
sfr ADC_CONTR = 0xBC;        //带AD系列
sfr ADC_RES   = 0xBD;        //带AD系列
sfr ADC_RESL  = 0xBE;        //带AD系列

sfr AUXR        =   0x8E;   //0000,0000 辅助寄存器

sfr P0M0        =   0x94;   //0000,0000 端口0模式寄存器0
sfr P0M1        =   0x93;   //0000,0000 端口0模式寄存器1
sfr P1M0        =   0x92;   //0000,0000 端口1模式寄存器0
sfr P1M1        =   0x91;   //0000,0000 端口1模式寄存器1
sfr P2M0        =   0x96;   //0000,0000 端口2模式寄存器0
sfr P2M1        =   0x95;   //0000,0000 端口2模式寄存器1
sfr P3M0        =   0xB2;   //0000,0000 端口3模式寄存器0
sfr P3M1        =   0xB1;   //0000,0000 端口3模式寄存器1
sfr P4M0        =   0xB4;   //0000,0000 端口4模式寄存器0
sfr P4M1        =   0xB3;   //0000,0000 端口4模式寄存器1
sfr P5M0        =   0xCA;   //0000,0000 端口5模式寄存器0
sfr P5M1        =   0xC9;   //0000,0000 端口5模式寄存器1
sfr P6M0        =   0xCC;   //0000,0000 端口6模式寄存器0
sfr P6M1        =   0xCB;   //0000,0000 端口6模式寄存器1
sfr P7M0        =   0xE2;   //0000,0000 端口7模式寄存器0
sfr P7M1        =   0xE1;   //0000,0000 端口7模式寄存器1



//                                                                7       6      5       4         3      2    1    0   Reset Value
//sfr ADC_CONTR = 0xBC;                ADC_POWER SPEED1 SPEED0 ADC_FLAG ADC_START CHS2 CHS1 CHS0 0000,0000        //AD 转换控制寄存器
#define ADC_OFF()        ADC_CONTR = 0
#define ADC_ON                (1 << 7)
#define ADC_90T                (3 << 5)
#define ADC_180T        (2 << 5)
#define ADC_360T        (1 << 5)
#define ADC_540T        0
#define ADC_FLAG        (1 << 4)        //软件清0
#define ADC_START        (1 << 3)        //自动清0
#define ADC_CH0                0
#define ADC_CH1                1
#define ADC_CH2                2
#define ADC_CH3                3
#define ADC_CH4                4
#define ADC_CH5                5
#define ADC_CH6                6
#define ADC_CH7                7
/************* ADC通道选择 **************/
uint        adc10_start(uchar channel);        //channel = 0~7
uint        j;          //ADC值临时存储

/******************************************************************/
/*                   函数声明2                                    */
/******************************************************************/
        void  KeyInit(void);
        void  GetKey(uint *pKeyValue);

        void  Disp_Out(uchar wei,uchar shu);
        void  LedOnOff(void);
        void  TimerInit(void);
        void  KeyChuli(void);
        void  FunChuli(void); //功能处理
        void  Display(void); //显示函数

        void  delay_ms(unsigned char ms);

/******************************************************************/
/*                   按键判断相关变量定义                         */
/******************************************************************/
        /* 按键键值宏定义 */
        #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 按下延时

/******************************************************************/
/*                    变量定义开始                                */
/******************************************************************/
        /* 定义定时中断变量*/
        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;

        /* 定义数据传输存储数组*/  
        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

        /* 定义数码管显示变量*/
        uchar code disp[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E,0x89,0x8c,0xc1,0xff,0xbf,0x9c};         
                                        //         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};

        uint disp_count;       

/******************************************************************/
/*            I/O定义                                             */
/******************************************************************/
        sbit  Func_Led1=P3^3;      //功能1指示
        sbit  Func_Led2=P3^4;                //功能2指示
        sbit  Func_Led3=P3^5;                //功能3指示


        sbit  TimeOn_Led=P3^0;                //预约指示
        sbit  TimeOff_Led=P3^1;                //定时指示
        sbit  Relay=P1^3;  //定时  继电器输出                
        sbit  Beep=P1^1;       //蜂鸣器
        //sbit  test=P1^2;
/******************************************************************/
/*定义不同的显示数码,解决不同的数数码用不同的单片机的端口                  */
/******************************************************************/       
        uchar bdata dport,dport2;//定义不同的显示数码,解决不同的数数码用不同的单片机的端口
        sbit dp0=P0^4;
        sbit dp1=P0^5;
        sbit dp2=P2^3;
        sbit dp3=P2^6;
        sbit dp4=P2^4;
        sbit dp5=P0^2;
        sbit dp6=P0^7;
        sbit dp7=P2^5;
        sbit bit4=P0^3;
        sbit bit3=P0^6;
        sbit bit2=P2^7;
        sbit bit1=P2^2;
       
        sbit d0=dport^0;
        sbit d1=dport^1;
        sbit d2=dport^2;
        sbit d3=dport^3;
        sbit d4=dport^4;
        sbit d5=dport^5;
        sbit d6=dport^6;
        sbit d7=dport^7;

        #define        wei1   0x01
        #define        wei2   0x02
    #define        wei3   0x03
        #define        wei4   0x04
        #define        wei_all   0x00

/******************************************************************/
/*                    延时函数                                    */
/******************************************************************/
        void YS14520us(void)   
        {
            uint a,b,c;
            for(c=2;c>0;c--)
                for(b=238;b>0;b--)
                    for(a=90;a>0;a--);
        }
       
        void YS660us(void)   
        {
            uint a,b,c;
            for(c=2;c>0;c--)
                for(b=94;b>0;b--)
                    for(a=9;a>0;a--);
        }
       
        void YS30us(void)   
        {
            uint a;
             for(a=87;a>0;a--);
        }
       
        void YSms(uint n)
        {
        uint a,b;
        while(n)
        {
            for(b=222;b>0;b--)
                for(a=12;a>0;a--);
            n--;
        }
        }

/******************************************************************/
/*              段码使用不同IO的转换                              */
/******************************************************************/
        void disp_data()
        {
       
                if(d0==1) dp0=1;
                if(d1==1) dp1=1;
                if(d2==1) dp2=1;
                if(d3==1) dp3=1;
                if(d4==1) dp4=1;
                if(d5==1) dp5=1;
                if(d6==1) dp6=1;
                if(d7==1) dp7=1;
               
                if(d0==0) dp0=0;
                if(d1==0) dp1=0;
                if(d2==0) dp2=0;
                if(d3==0) dp3=0;
                if(d4==0) dp4=0;
                if(d5==0) dp5=0;
                if(d6==0) dp6=0;
                if(d7==0) dp7=0;
       
        }
/******************************************************************/
/*                    显示函数                                    */
/******************************************************************/
        void Disp_Out(uchar wei,uchar shu) //显示数据函数
     {
         
                P3M0 |= 0xfc;          //推挽输出
                P0M0 |= 0xfc;          //推挽输出
                P2M0 |= 0xfc;          //推挽输出

                bit1=0;  // 初始化位
                bit2=0;  // 初始化位
                bit3=0;  // 初始化位
                bit4=0;  // 初始化位

                dport=disp[shu];         //将要显示的数的编码赋值给 自定义端口
                disp_data();          // 将自定义端口的值(段码)转换为实际IO
                                                   //选择显示的位
       switch(wei)
       {
                case 0:
         {  
                  bit1=1;
                        bit2=1;
                        bit3=1;  
                        bit4=1;  
                          YSms(2);
           }
          break;
                case 1:
         {  
          bit1=1;
                  YSms(2);
           }
          break;
                case 2:
         {  
          bit2=1;
                  YSms(2);
           }
          break;
                case 3:
         {  
          bit3=1;
                  YSms(2);
           }
          break;
                case 4:
         {  
          bit4=1;
                  YSms(2);
           }
          break;
       }
     }
/******************************************************************/
/*                   定时器初始化函数                             */
/******************************************************************/                                       
void TimerInit(void)                //20毫秒@22.1184MHz
{
         AUXR |= 0x80;                         //定时器0为1T模式
        //AUXR &= 0x7f;                        //定时器0为12T模式
    TMOD |= 0x00;                    //设置定时器为模式0(16位自动重装载)
    TL0 = T20MS;                     //初始化计时值
    TH0 = T20MS >> 8;
//        TF0 = 0;                //清除TF0标志
    TR0 = 1;                        //定时器0开始计时
    ET0 = 1;                        //使能定时器0中断
    //EA = 1;                                //开总中断
}


/******************************************************************/
/*                   定时中断函数                                 */
/******************************************************************/
        //void tm0_isr() interrupt 1 using 1
        void  Timer0(void) interrupt 1          // 定时器中断处理函数
        {
        //        TH0 = 0x70;
        //        TL0 = 0x00;
                bTime20mS = 1;
                flash_1s ++;
                //test = !test ;

                //******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]-- ;
                                        }
                                }
                     }
                  }
                                                     
        }
/******************************************************************/
/*                   底层按键扫描函数                             */
/******************************************************************/
        uint  KeyScan(void)
        {       
               
                P1M0 |= 0xfc;          //推挽输出
                if(j>500&j<1000)
                {  
                        return KEY_VALUE2;                           //0x0e
                }
                else if(j>200&j<400)
                {
                        return KEY_VALUE3;
                }
                else if(j>=0&j<199)
                {       
                        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 ;            //返回按键值和按键状态       
        }
/******************************************************************/
/*                   按键处理函数                                 */
/******************************************************************/
        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;
                                        //自动输出1
                                        }
                                        if( FlagFunc==2 )
                                        {
                                        DataBuf[5]=8;
                                        DataBuf[6]=30;
                                        DataBuf[7]=0;
                                        DataBuf[8]=0;
                                        DataBuf[9]=30;
                                        DataBuf[10]=3;
                                        //煮粥输出1
                                        }
                                        if( FlagFunc==3 )
                                        {
                                        DataBuf[5]=0;
                                        DataBuf[6]=0;
                                        DataBuf[7]=0;
                                        DataBuf[8]=5;
                                        DataBuf[9]=1;
                                        DataBuf[10]=0;
                                        //猪排骨汤输出1
                                        }
                                }               
                        }
                }
                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连续
                {
                         if( FuncStart != 1 )
                        {
                                FlagFunc=1;
                                if( FlagFunc==1 )
                                        {
                                        DataBuf[5]=8;
                                        DataBuf[6]=30;
                                        DataBuf[7]=5;
                                        DataBuf[8]=0;
                                        DataBuf[9]=10;
                                        DataBuf[10]=0;
                                        }
                           FlagTimeOff=1;
                        }
                }
                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]>=2 )
                {
                 DataBuf[8]=0;
                }
                  /*****按键蜂鸣程序*****/
                if( KeyValue != KEY_NULL ) //只要有按键按下
                {
                 Beepshort=1;
                }
        }
/******************************************************************/
/*                   指示灯亮灭闪烁函数                              */
/******************************************************************/
        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  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 )
                {
                 switch(FlagFunc)                 //根据功能状态选择
                        {
                                case  0:           //无功能 继电器无输出
                                {
                                 Relay=1;       
                                }
                                break;
                                case  1:                 //功能1 高温
                                {
                                 Relay=0;       
                                }
                                break;
                        }
                }
                else
                {
                        Relay=1;       
                }
        }

/******************************************************************/
/*                   显示函数                                 */
/******************************************************************/
        void  Display(void)
        {

                /*****显示输出*****/
                if( FlagFunc!=0 )        //选择相应功能后才显示预约定时时间
                {
/*                       
                        Disp_Out(wei1,j%10) ;                //用于显示ADC检测值 方便按键判断
                        Disp_Out(wei2,j%100/10) ;
                        Disp_Out(wei3,j%1000/100) ;
                        Disp_Out(wei4,j/1000) ;
*/

                        Disp_Out(wei4,h/10) ;       
                        Disp_Out(wei3,h%10) ;
                        Disp_Out(wei2,m/10) ;
                        Disp_Out(wei1,m%10) ;
                        //Disp_Out(wei4,s/10) ;
                        //Disp_Out(wei3,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)
{
        TimerInit();          /* 定时器初始化函数 */
        EA = 1;          //开总中断
        P1ASF = (1 << ADC_CH0);                        //12C5A60AD/S2系列模拟输入(AD)选择
        ADC_CONTR = ADC_540T | ADC_ON;
        Disp_Out(wei_all,0) ;

        delay_ms(250);
        delay_ms(250);
        delay_ms(250);
        delay_ms(250);

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

/********************* 做一次ADC转换 *******************/
uint        adc10_start(uchar channel)        //channel = 0~7
{
        uint        adc;
        uchar        i;

        ADC_RES = 0;
        ADC_RESL = 0;

        ADC_CONTR = (ADC_CONTR & 0xe0) | ADC_START | channel;

        //for(i=0; i<250; i++)                //13T/loop, 40*13=520T=23.5us @ 22.1184M
        i = 250;
        do{
                if(ADC_CONTR & ADC_FLAG)
                {
                        ADC_CONTR &= ~ADC_FLAG;
                //        adc = 0;
                //        adc = (ADC_RES << 8) | ADC_RESL;        //ADRJ_enable()
                        adc = (uint)ADC_RES;
                        adc = (adc << 2) | (ADC_RESL & 3);
                        return        adc;
                }
        }while(--i);
        return        1024;
}

//========================================================================
// 函数: void  delay_ms(unsigned char ms)
// 描述: 延时函数。
// 参数: ms,要延时的ms数.
// 返回: none.
// 版本: VER1.0
// 日期: 2010-12-15
// 备注:
//========================================================================
void  delay_ms(unsigned char ms)
{
     unsigned int i;
         do{
              i = MAIN_Fosc / 14000;
                  while(--i)        ;   //14T per loop
     }while(--ms);
}






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

知道什么是神吗？其实神本来也是人，只不过神做了人做不到的事情 所以才成了神。 （头文字D, 杜汶泽）
回复

   举报本楼层   

Eric2013

出0入0汤圆
发表于 2013-8-11 18:08:23 | 显示全部楼层
楼主这么问问题，估计能帮到你的比较少，最好可以把问题具体某一方面
回复

   举报本楼层   

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

本版积分规则

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

GMT+8, 2024-7-23 16:16

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

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