STC89C52单片机制作自动窗帘机(转载保存待制作)

2020-12-08 小编:伟轩 分类:DIY文章教程 阅读(347)
分享到:
关闭
听奇闻 - STC89C52单片机制作自动窗帘机(转载保存待制作)
00:00 / 00:00

+

-

语速: 慢速 默认 快速
- 5 +
自动播放×

御姐音

大叔音

萝莉音

型男音

温馨提示:
是否自动播放下一条内容?
立即播放当前内容?
确定
确定
取消
功能包括,设定时间开闭窗帘和光控开闭窗帘两种模式,通过模式转换来设定时间和光控的阈值。这个制作比较有实用价值,适合单片机爱好者来制作和改进。先上电路图







程序:


单片机源程序如下:

#include

#include

#include

 

 

void io_inithw(void);

void int_init(void);

void io_inithw(void)

{

        P0=0xff;

        P1=0xff;

        P2=0xff;

        P3=0xff;

}

 

void int_inithw(void)

{

        EX0=1;

        EA=1;

}

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

// 毫秒级的延时函数,time是要延时的毫秒数

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

void DelayMs(uint time)

{

        uint i,j;

        for(i=0;i

                for(j=0;j<112;j++);

}

 

 

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

// 1602液晶写命令函数,cmd就是要写入的命令

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

void LcdWriteCmd(uchar cmd)

{

        LcdRs_P = 0;

        LcdRw_P = 0;

        LcdEn_P = 0;

        P0=cmd;

        DelayMs(2);

        LcdEn_P = 1;   

        DelayMs(2);

        LcdEn_P = 0;        

}

 

 

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

// 1602液晶写数据函数,dat就是要写入的数据

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

void LcdWriteData(uchar dat)

{

        LcdRs_P = 1;

        LcdRw_P = 0;

        LcdEn_P = 0;

        P0=dat;

        DelayMs(2);

        LcdEn_P = 1;   

        DelayMs(2);

        LcdEn_P = 0;

}

 

 

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

// 1602液晶初始化函数

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

void LcdInit()

{

        LcdWriteCmd(0x38);        // 16*2显示,5*7点阵,8位数据口

        LcdWriteCmd(0x0C);        // 开显示,不显示光标

        LcdWriteCmd(0x06);        // 地址加1,当写入数据后光标右移

        LcdWriteCmd(0x01);        // 清屏

}

 

 

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

// 液晶光标定位函数

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

void LcdGotoXY(uchar line,uchar column)

{

        // 第一行

        if(line==0)        

                LcdWriteCmd(0x80+column);

        // 第二行

        if(line==1)        

                LcdWriteCmd(0x80+0x40+column);

}

 

 

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

// 液晶输出字符串函数

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

void LcdPrintStr(uchar *str)

{

        while(*str!='')

                        LcdWriteData(*str++);

}

 

 

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

// 液晶输出数字(0-99)

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

void LcdPrintNum(uchar num)

{

        LcdWriteData(num/10+48);                // 十位

        LcdWriteData(num%10+48);                 // 个位

}

 

 

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

// 显示模式

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

void LcdPrintMode(uchar num)

{

        switch(num)                        

        {

                case 1: LcdPrintStr("Manual");        break;

                case 2: LcdPrintStr("Timing");        break;

                case 3: LcdPrintStr("Liging");        break;

                default:                                                                                                break;

        }

}

 

 

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

// 液晶显示内容的初始化

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

void LcdShowInit()

{

        LcdGotoXY(0,0);

        LcdPrintStr("20  -  -     :  ");

        LcdGotoXY(1,0);

        LcdPrintStr("           gz:  ");

        LcdGotoXY(1,0);

        LcdPrintMode(gMode);

}

 

 

 

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

// 刷新时间显示

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

void FlashTime()

{

        LcdGotoXY(0,2);                                                                                // 年份

        LcdPrintNum(TimeBuff[0]);

        LcdGotoXY(0,5);                                                                                // 月份

        LcdPrintNum(TimeBuff[1]);

        LcdGotoXY(0,8);                                                                                // 日期

        LcdPrintNum(TimeBuff[2]);

        LcdGotoXY(0,11);                                                                        // 小时

        LcdPrintNum(TimeBuff[4]);

        LcdGotoXY(0,14);                                                                        // 分钟

        LcdPrintNum(TimeBuff[5]);

        LcdGotoXY(0,13);                                                                        // 秒钟

        if(TimeBuff[6]%2==0)                                                        // 秒钟是偶数显示冒号

                LcdWriteData(':');

        else                                                                                                                        // 秒钟是奇数显示空格

                LcdWriteData(' ');

}

 

#p#副标题#e#

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

// 初始化DS1302

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

void DS1302_Init(void)

{

        RST_P=0;                        // RST脚置低

        SCK_P=0;                        // SCK脚置低

        SDA_P=0;                        // SDA脚置低                                

}

 

 

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

// 从DS1302读出一字节数据

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

uchar DS1302_Read_Byte(uchar addr)

{

        uchar i;

        uchar temp;

        

        RST_P=1;       
  /* 写入目标地址:addr*/

        for(i=0;i<8;i++)

        {     

                if(addr&0x01)

                        SDA_P=1;

                else

                        SDA_P=0;

               

                SCK_P=1;

                _nop_();

                SCK_P=0;

                _nop_();

               

                addr=addr>> 1;

        }

        

        /* 读出该地址的数据 */

        for(i=0;i<8;i++)

        {

                temp=temp>>1;

               

                if(SDA_P)

                        temp|= 0x80;

                else

                        temp&=0x7F;

               

                SCK_P=1;

                _nop_();

                SCK_P=0;

                _nop_();

        }

        

        RST_P=0;

        

        return temp;

}

 

 

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

// 向DS1302写入一字节数据

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

void DS1302_Write_Byte(uchar addr, uchar dat)

{

        uchar i;

        

        RST_P = 1;

        

        /* 写入目标地址:addr*/

        for(i=0;i<8;i++)

        {

                if(addr&0x01)

                        SDA_P=1;

                else

                        SDA_P=0;

 

                SCK_P=1;

                _nop_();

                SCK_P=0;

                _nop_();

               

                addr=addr>>1;

        }

        

        /* 写入数据:dat*/

        for(i=0;i<8;i++)

        {

                if(dat&0x01)

                        SDA_P=1;

                else

                        SDA_P=0;

        

                SCK_P=1;

                _nop_();

                SCK_P=0;

                _nop_();

               

                dat=dat>>1;

        }

        

        RST_P=0;                                       

}

 

#p#副标题#e#

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

// 向DS1302写入时间数据

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

void DS1302_Write_Time()

{

  uchar i;

        uchar temp1;

        uchar temp2;

        

        for(i=0;i<7;i++)                        // 十进制转BCD码

        {

                temp1=(TimeBuff[i]/10)<<4;

                temp2=TimeBuff[i]%10;

                TimeBuff[i]=temp1+temp2;

        }

        

        DS1302_Write_Byte(0x8E,0x00);                                                                // 关闭写保护

        DS1302_Write_Byte(0x80,0x80);                                                                // 暂停时钟

        DS1302_Write_Byte(0x8C,TimeBuff[0]);                                // 年

        DS1302_Write_Byte(0x88,TimeBuff[1]);                                // 月

        DS1302_Write_Byte(0x86,TimeBuff[2]);                                // 日

        DS1302_Write_Byte(0x8A,TimeBuff[3]);                                // 星期

        DS1302_Write_Byte(0x84,TimeBuff[4]);                                // 时

        DS1302_Write_Byte(0x82,TimeBuff[5]);                                // 分

        DS1302_Write_Byte(0x80,TimeBuff[6]);                                // 秒

        DS1302_Write_Byte(0x80,TimeBuff[6]&0x7F);                // 运行时钟

        DS1302_Write_Byte(0x8E,0x80);                                                                // 打开写保护  

}

 

 

 

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

// 从DS1302读出时间数据

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

void DS1302_Read_Time()  

{

        uchar i;

 

        TimeBuff[0]=DS1302_Read_Byte(0x8D);                                                // 年

        TimeBuff[1]=DS1302_Read_Byte(0x89);                                                // 月

        TimeBuff[2]=DS1302_Read_Byte(0x87);                                                // 日

        TimeBuff[3]=DS1302_Read_Byte(0x8B);                                                // 星期

        TimeBuff[4]=DS1302_Read_Byte(0x85);                                                // 时

        TimeBuff[5]=DS1302_Read_Byte(0x83);                                                // 分

        TimeBuff[6]=(DS1302_Read_Byte(0x81))&0x7F;                // 秒

 

        for(i=0;i<7;i++)                // BCD转十进制

        {           

                TimeBuff[i]=(TimeBuff[i]/16)*10+TimeBuff[i]%16;

        }

}

 

 

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

// ADC0832的时钟脉冲

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

void WavePlus()

{

        _nop_();

        ADC_CLK = 1;

        _nop_();

        ADC_CLK = 0;

}

 

#p#副标题#e#

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

// 获取指定通道的A/
 

D转换结果

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

uchar Get_ADC0832()

{

        uchar i;

        uchar dat1=0;

        uchar dat2=0;

        

        ADC_CLK = 0;                                // 电平初始化

        ADC_DAT = 1;

        _nop_();

        ADC_CS = 0;

        WavePlus();                                        // 起始信号

        ADC_DAT = 1;

        WavePlus();                                        // 通道选择的第一位

        ADC_DAT = 0;      

        WavePlus();                                        // 通道选择的第二位

        ADC_DAT = 1;

        

        for(i=0;i<8;i++)                // 第一次读取

        {

                dat1<<=1;

                WavePlus();

                if(ADC_DAT)

                        dat1=dat1|0x01;

                else

                        dat1=dat1|0x00;

        }

        

        for(i=0;i<8;i++)                // 第二次读取

        {

                dat2>>= 1;

                if(ADC_DAT)

                        dat2=dat2|0x80;

                else

                        dat2=dat2|0x00;

                WavePlus();

        }

        

        _nop_();                                                // 结束此次传输

        ADC_DAT = 1;

        ADC_CLK = 1;

        ADC_CS  = 1;   

 

        if(dat1==dat2)                        // 返回采集结果

                return dat1;

        else

                return 0;

}

 

 

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

// 按键扫描(设置当前时间)

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

void KeyScanf1()

{

        if(KeySet_P==0)

        {

                LcdGotoXY(0,13);                                // 显示秒钟的冒号

                LcdWriteData(':');

                LcdWriteCmd(0x0f);                        // 启动光标闪烁

                LcdGotoXY(0,3);                                        // 定位光标到年份闪烁

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet_P);                                // 等待按键释放

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

               

                /* 调整年份 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(TimeBuff[0]>0)                                                // 判断年份是否大于0               

                                        TimeBuff[0]--;                                                // 是的话就减去1

                                LcdGotoXY(0,2);                                                        // 光标定位到年份的位置

                                LcdPrintNum(TimeBuff[0]);                // 刷新显示改变后的年份

                                LcdGotoXY(0,3);                                                        // 定位光标到年份闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(TimeBuff[0]<99)                                        // 判断年份是否小于99

                                        TimeBuff[0]++;                                                // 是的话就加上1

                                LcdGotoXY(0,2);                                                        // 光标定位到年份的位置

                                LcdPrintNum(TimeBuff[0]);                // 刷新显示改变后的年份

                                LcdGotoXY(0,3);                                                        // 定位光标到年份闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(0,6);                                        // 定位光标到月份闪烁

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet_P);                                // 等待按键释放

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

                        

                /* 调整月份 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(TimeBuff[1]>1)                                                // 判断月份是否大于1               

                                        TimeBuff[1]--;                                                // 是的话就减去1

                                LcdGotoXY(0,5);                                                        // 光标定位到月份的位置

                                LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份

                                LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(TimeBuff[1]<12)                                        // 判断月份是否小于12

                                        TimeBuff[1]++;                                                // 是的话就加上1

                                LcdGotoXY(0,5);                                                        // 光标定位到月份的位置

                                LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份

                                LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(0,9);                                        // 定位光标到日期闪烁

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet_P);                                // 等待按键释放

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

               

                /* 调整日期 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

if(TimeBuff[2]>1) // 判断日期是否大于1
 

                                if(TimeBuff[2]>1)                                                // 判断日期是否大于1               

                                        TimeBuff[2]--;                                                // 是的话就减去1

                                LcdGotoXY(0,8);                                                        // 光标定位到日期的位置

                                LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期

                                LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(TimeBuff[2]<31)                                        // 判断日期是否小于31

                                        TimeBuff[2]++;                                                // 是的话就加上1

                                LcdGotoXY(0,8);                                                        // 光标定位到日期的位置

                                LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期

                                LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(0,12);                                // 定位光标到小时闪烁

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet_P);                                // 等待按键释放

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

               

               

                /* 调整小时 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(TimeBuff[4]>0)                                                // 判断小时是否大于0

                                        TimeBuff[4]--;                                                // 是的话就减去1

                                LcdGotoXY(0,11);                                                // 光标定位到小时的位置

                                LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时

                                LcdGotoXY(0,12);                                                // 定位光标到小时闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(TimeBuff[4]<23)                                        // 判断小时是否小于23

TimeBuff[4]++;
#p#副标题#e#

                                        TimeBuff[4]++;                                                // 是的话就加上1

                                LcdGotoXY(0,11);                                                // 光标定位到小时的位置

                                LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时

                                LcdGotoXY(0,12);                                                // 定位光标到小时闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(0,15);                                // 定位光标到分钟闪烁

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet_P);                                // 等待按键释放

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

               

                /* 调整分钟 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(TimeBuff[5]>0)                                                // 判断分钟是否大于0

                                        TimeBuff[5]--;                                                // 是的话就减去1

                                LcdGotoXY(0,14);                                                // 光标定位到分钟的位置

                                LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟

                                LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(TimeBuff[5]<59)                                        // 判断分钟是否小于59

                                        TimeBuff[5]++;                                                // 是的话就加上1

                                LcdGotoXY(0,14);                                                // 光标定位到分钟的位置

                                LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟

                                LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet_P==0)

                        {

                                break;

                        }

                }

               

                /* 退出前的设置 */

                LcdWriteCmd(0x0C);                        // 关闭光标闪烁

                DS1302_Write_Time();                // 把新设置的时间值存入DS1302芯片

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet_P);                                // 等待按键释放

DelayMs(10);

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

        }

}

 

 

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

// 按键扫描(设置窗帘的动作)

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

void KeyScanf2()

{

        if(KeySet2_P==0)

        {

                LcdGotoXY(0,0);                                                                                // 光标定位

                LcdPrintStr(" OpenTime   :   ");        // 显示第1行内容

                LcdGotoXY(1,0);                                                                                // 光标定位

                LcdPrintStr("CloseTime   :   ");        // 显示第2行内容

                LcdGotoXY(0,10);                                                                        // 光标定位

                LcdPrintNum(OpenHour);                                                // 显示开启窗帘的小时

                LcdGotoXY(0,13);                                                                        // 光标定位

                LcdPrintNum(OpenMinute);                                        // 显示开启窗帘的分钟

                LcdGotoXY(1,10);                                                                        // 光标定位

                LcdPrintNum(CloseHour);                                                // 显示关闭窗帘的小时

                LcdGotoXY(1,13);                                                                        // 光标定位

                LcdPrintNum(CloseMinute);                                        // 显示关闭窗帘的分钟               

               

                LcdWriteCmd(0x0f);                                                        // 启动光标闪烁

                LcdGotoXY(0,11);                                                                // 定位光标

                DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动

                while(!KeySet2_P);                                                        // 等待按键释放

                DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动

               

                /* 调整开启的小时 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(OpenHour>0)                                                        // 判断小时是否大于0               

                                        OpenHour--;                                                                // 是的话就减去1

                                LcdGotoXY(0,10);                                                // 光标定位

                                LcdPrintNum(OpenHour);                        // 刷新显示改变后的小时

                                LcdGotoXY(0,11);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(OpenHour<23)                                                        // 判断小时是否小于23

                                        OpenHour++;                                                                // 是的话就加上1

LcdGotoXY(0,10);

#p#副标题#e#
 

                                LcdGotoXY(0,10);                                                // 光标定位

                                LcdPrintNum(OpenHour);                        // 刷新显示改变后的小时

                                LcdGotoXY(0,11);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet2_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(0,14);                                                                // 定位光标

                DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动

                while(!KeySet2_P);                                                        // 等待按键释放

                DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动

               

                /* 调整开启的分钟 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(OpenMinute>0)                                                // 判断分钟是否大于0

                                        OpenMinute--;                                                        // 是的话就减去1

                                LcdGotoXY(0,13);                                                // 光标定位

                                LcdPrintNum(OpenMinute);                // 刷新显示改变后的分钟

                                LcdGotoXY(0,14);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(OpenMinute<59)                                                // 判断分钟是否小于59

                                        OpenMinute++;                                                        // 是的话就加上1

                                LcdGotoXY(0,13);                                                // 光标定位

                                LcdPrintNum(OpenMinute);                // 刷新显示改变后的分钟

                                LcdGotoXY(0,14);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet2_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(1,11);                                                                // 定位光标

                DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动

while(!KeySet2_P); // 等待按键释
 

             while(!KeySet2_P);                                                        // 等待按键释放

                DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动

               

                /* 调整关闭的小时 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(CloseHour>0)                                                        // 判断小时是否大于0               

                                        CloseHour--;                                                        // 是的话就减去1

                                LcdGotoXY(1,10);                                                // 光标定位

                                LcdPrintNum(CloseHour);                        // 刷新显示改变后的小时

                                LcdGotoXY(1,11);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(CloseHour<23)                                                // 判断小时是否小于23

                                        CloseHour++;                                                        // 是的话就加上1

                                LcdGotoXY(1,10);                                                // 光标定位

                                LcdPrintNum(CloseHour);                        // 刷新显示改变后的小时

                                LcdGotoXY(1,11);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet2_P==0)

                        {

                                break;

                        }

                }

               

                LcdGotoXY(1,14);                                                                // 定位光标

                DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动

                while(!KeySet2_P);                                                        // 等待按键释放

                DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动

               

                /* 调整关闭的分钟 */

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(CloseMinute>0)                                                // 判断分钟是否大于0

                                        CloseMinute--;                                                // 是的话就减去1

                                LcdGotoXY(1,13);                                                // 光标定位

                                LcdPrintNum(CloseMinute);                // 刷新显示改变后的分钟

LcdGotoXY(1,14);

#p#副标题#e#

                               LcdGotoXY(1,14);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(CloseMinute<59)                                        // 判断分钟是否小于59

                                        CloseMinute++;                                                // 是的话就加上1

                                LcdGotoXY(1,13);                                                // 光标定位

                                LcdPrintNum(CloseMinute);                // 刷新显示改变后的分钟

                                LcdGotoXY(1,14);                                                // 定位光标

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet2_P==0)

                        {

                                break;

                        }

                }

               

                DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动

                while(!KeySet2_P);                                                        // 等待按键释放

                DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动

               

                /* 光照强度的设置 */

                LcdWriteCmd(0x0C);                                                                // 关闭光标闪烁

                LcdGotoXY(0,0);                                                                                // 光标定位

                LcdPrintStr("   Light Set    ");        // 显示第1行内容

                LcdGotoXY(1,0);                                                                                // 光标定位

                LcdPrintStr("                ");        // 显示第2行内容

                LcdGotoXY(1,7);                                                                                // 光标定位

                LcdPrintNum(gLight);                                                        // 显示窗帘的光线控制强度阈值

               

                while(1)

                {

                        if(KeyDown_P==0)                                                        // 如果减按键被下去

                        {

                                if(gLight>0)                                                                // 判断光线阈值是否大于0

                                        gLight--;                                                                        // 是的话就减去1

                                LcdGotoXY(1,7);                                                        // 光标定位

                                LcdPrintNum(gLight);                                // 刷新显示改变后的光线阈值

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

if(KeyUp_P==0) // 如果加按键被下去
 

                        if(KeyUp_P==0)                                                                // 如果加按键被下去

                        {

                                if(gLight<99)                                                                // 判断光线阈值是否小于59

                                        gLight++;                                                                        // 是的话就加上1

                                LcdGotoXY(1,7);                                                        // 光标定位

                                LcdPrintNum(gLight);                                // 刷新显示改变后的光线阈值

                                DelayMs(300);                                                                // 延时0.3秒左右

                        }

                        

                        if(KeySet2_P==0)

                        {

                                break;

                        }

                }

               

                /* 退出前的设置 */

                LcdShowInit();                                        // 液晶显示内容初始化

                DelayMs(10);                                                // 延时等待,消除按键按下的抖动

                while(!KeySet2_P);                        // 等待按键释放

                DelayMs(10);                                                // 延时等待,消除按键松开的抖动

        }

}

 

 

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

// 按键扫描(模式切换)

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

void KeyScanf3()

{

        if(KeyMode_P==0)

        {

                gMode++;                                                        // 切换到下一模式

                if(gMode==4)                                        // 如果到尽头了

                        gMode=1;                                                // 回到第一种模式

                LcdGotoXY(1,0);                                // 光标定位

                LcdPrintMode(gMode);        // 显示模式

                DelayMs(10);                                        // 去除按键按下的抖动

                while(!KeyMode_P);                // 等待按键是否

                DelayMs(10);                                        // 去除按键松开的抖动

        }

}

 

 

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

// 开窗

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

void Open()

{

        uint i,j;

        for(j=0;j<255;j++)                // 控制步进电机正转

        {

                for(i=0;i<4;i++)

                {

                        P2=Clock[i];

                        DelayMs(3);

                }

        }

        Led_P=0;

}

 

 

 

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

// 关窗

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

void Close()

{

        uint i,j;

        for(j=0;j<255;j++)                // 控制步进电机反转

        {

                for(i=0;i<4;i++)

                {

                        P2=AntiClock[i];

                        DelayMs(3);

                }

        }

        Led_P=1;

}

 

 

 

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

// 主函数

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

void main()

{

        uchar light;

        

        LcdInit();                        // 执行液晶初始化        

        DS1302_Init();        // 时钟芯片的初始化

        LcdShowInit();        // 液晶显示内容的初始化

        io_inithw();

        int_inithw();

        if(DS1302_Read_Byte(0x81)>=128)                        // 判断时钟芯片是否正在运行

        {

                DS1302_Write_Time();                                                        // 如果没有,则初始化一个时间

        }

        

        while(1)

        {

                DS1302_Read_Time();                                // 获取当前时钟芯片的时间,存在数组time_buf中

                FlashTime();                                                        // 刷新时间显示

 

                light=Get_ADC0832();                        // 读取光照强度

                light=light/2.5;                                        // 缩小光照检测结果(在0-99)

 

if(light>99)
#p#副标题#e#

           if(light>99)                                                        // 如果大于99

                        light=99;                                                                // 则依然保持99

                LcdGotoXY(1,14);                                        // 光标定位

                LcdPrintNum(light);                                // 显示光照强度

               

                KeyScanf1();                                                        // 按键扫描(时间的设置)

                KeyScanf2();                                                        // 按键扫描(阈值的设置)

                KeyScanf3();                                                        // 按键扫描(模式切换)

        

                /*手动控制模式*/

                if(gMode==1)

                {

                        if(closeflag==1)

                        {

                                if(Led_P==0)                        // 如果窗帘当前是打开的

                                {

                                        closeflag=0;

                                        Close();                                // 则光标窗帘

                                }else

                                closeflag=0;

                        }

                        if(KeyDown_P==0)                // 如果关窗帘键按下了        

                        {

                                if(Led_P==0)                        // 如果窗帘当前是打开的

                                {

                                        Close();                                // 则光标窗帘

                                }

                        }

                        if(openflag==1)

                        {

                                if(Led_P==1)                        // 如果窗帘当前是关闭的

                                {

                                        openflag=0;

                                        Open();                                        // 则打开窗帘

                                }else{

                                        openflag=0;

                                }

                                

                        }

                        if(KeyUp_P==0)                        // 如果开窗帘键按下了

                        {

                                if(Led_P==1)                        // 如果窗帘当前是关闭的

……………………

                     

献吻 70

巴掌 57

发表评论
内容:
剩余字数:360/360


     :: 正在为您加载评论……


每页10条,共0
热门图片
公众号

微信扫一扫
公众号更精彩

返回顶部
X