M8,ICCAVR下的18B20程序

kkyou

/*  m818b20.c   2004-11-19  

  本程序为采用mega8 和18b20的温度采集程序

  选用mega8内部8M RC震荡，18b20 数据线接pd6,数据线和vcc间接一4.7k上拉电阻

  感谢dfgeoff 嗜血蜗牛提供的资料*/



#include <iom8v.h> //和单片机类型相对应的头文件，选择Atmega8做实验；

#include <macros.h>

#define uchar unsigned char

#define uint unsigned int

void init_1820();

write_1820(uchar x);

uchar read_1820();

void send_byte(uchar x);

void delay(uint x);

void disp_led(uchar buffer,uchar control);

uchar  disp_table[16] = {

        0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,

        0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};

uchar dp;

long count;

void main(void) //主函数

{

  disp_led(0,0);

  delay(2000);

  OSCCAL=0X9d;//系统时钟校准，不同的芯片和不同的频率，

  DDRC=0xff;

  DDRD=0XFF;

  PORTD=0XFF;

  WDR();       //看门狗计数清零

  WDTCR=0x0F;

  PORTC=0xff;

  while(1)

   {

                uchar i,temh,teml;

                init_1820();        //复位18b20

                write_1820(0xcc);   // 发出转换命令

                write_1820(0x44);

                delay(400);

                init_1820();

                WDR();

                write_1820(0xcc);  //发出读命令

                write_1820(0xbe);

                teml=read_1820();  //读数据

                temh=read_1820();

                //for(i=0;i<7;i++)    //测试用

                //{

                //send_byte(0x40);

                //send_byte(disp_table[0&0x0f]);

                       //}

                //send_byte(disp_table[temh>>4]);

                //send_byte(disp_table[temh&0x0f]);

                       //send_byte(disp_table[teml>>4]);

                //send_byte(disp_table[teml&0x0f]);

                count=(temh*256+teml)*6.25;  //计算具体温度

                WDR();

                       disp_led(0,1);     //显示温度

                for(i=0;i<100;i++)   //每次转换需要延时200ms以上

                delay(1000);      

                  }

}

void delay(uint x)  //1.5us左右

{

         while(x)

         {

            x--;

         }

}

void init_1820()

{

         PORTD|=(1<<6);   

         PORTD&=~(1<<6);

         delay(3000);    //480us以上

            PORTD|=(1<<6);

         DDRD&=~(1<<6);

         delay(40);     //15~60us

         while(PIND&(1<<6))

         {

           // disp_led(3,0);

                // for(;;)

                 //{}

        }

         DDRD|=(1<<6);

         PORTD|=(1<<6);

         delay(150);   //60~240us

}

write_1820(uchar x)

{   

     uchar m;

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

         {

              PORTD&=~(1<<6);

                 if(x&(1<<m))    //写数据，从低位开始

                 PORTD|=(1<<6);

                 else

                 PORTD&=~(1<<6);

                 delay(40);   //15~60us

                 PORTD|=(1<<6);

         }

          PORTD|=(1<<6);

}





uchar read_1820()

{   

         uchar temp,k,n;

           temp=0;

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

            {

                          PORTD&=~(1<<6);

                //delay(2);      

                PORTD|=(1<<6);

                //delay(3);   

                DDRD&=~(1<<6);

                k=(PIND&(1<<6));    //读数据,从低位开始

                if(k)

                temp|=(1<<n);

                else

                temp&=~(1<<n);

                delay(50); //60~120us   

                DDRD|=(1<<6);

        }

        return (temp);

}



void send_byte(uchar x)    //以下为显示程序

{

        uchar i;

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

        {

                PORTC&=~(1<<5);   // PC5为底  为164提供时钟信号

                if((x&(1<<(7-i)))||((dp==1)&&(i==0))) //判断每位数据的电平,及小数点判断

                PORTC|=(1<<4);                           //若为高着PC4输出高电平   

                else

                PORTC&=~(1<<4);                           //若为低着输出低电平

                PORTC|=(1<<5);   //PC5 提供始终信号

        }

        //PORTC|=((1<<0)|(1<<1)|(1<<2));

}

//显示程序 CONTROL为控制显示 BUFFER为显示数据

void disp_led(uchar buffer,uchar control)

{

        uchar i,temp[6];

        uint tempcount;

        dp=0;

        switch(control)

        {

                case 0:                //CONTROL为零全部数码管显示buffer  

                {

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

                        send_byte(disp_table[buffer%10]);//显示数字

                        break;

                }

                case 1:                //control为1，显示count中的数据为6位

                {

                        tempcount=count;

                        for(i=0;i<6;i++)   //取出每位中的数据

                        {

                                temp=tempcount%10;

                                tempcount/=10;

                        }

                        send_byte(disp_table[buffer/10]);  //最开始显示buffer数据

                        send_byte(disp_table[buffer%10]);

                        send_byte(0x00);         

                        send_byte(0x00);

                        send_byte(0x00);

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

                        {   

                            if(i==3)

                                dp=1;       //小数点控制位

                            send_byte(disp_table[temp[5-i]]);

                                dp=0;

                        }

                        break;

                }

        }

        PORTC|=(1<<4);

}

xiha365

研究研究，刚好有个18b20

谢了

armok

18b20 看来很常用啊。



大约零售价是多少？有空也找几个来玩玩。

kkyou

我去年11月在杭州电子市场买过一个12元开票，后来莫名其妙的坏掉了！



今年4个月前又买了一个开票是23元，听说现在已经到30了！

太贵了！！！

xiha365

这么贵啊，我的是别人给的两个 ：D

paley

谢了，我今天也刚刚编了一个M16下的18B20程序，等会一起讨论下

Jacky

可以在MAXIM的网站上申请免费样片。

8515

maxim的免费样片就像鸦片一样毒害广大工程师。 哈哈

fsclub

数码管是怎么接的？

ilan2003

maxim的东西感觉太贵了,虽然样片很好申请,我觉得这么贵的东西用到产品上的机会很少的.

为什么最近的温度传感芯片这么贵据说AD59也很贵,普通的应用用热敏电阻就够了,所以我觉得不要把时间花在不太用的到的芯片上去,即使你有样片.

pulan

ds18b20前一段时间传说好像停产了

好像现在又便宜了

我买的不开票9元

marker

我公司一直用TMP35/LM35D模拟的。价格也便宜。

ayu_612

上面的程序，有人用过吗？

gthgth

天津我买的是10元。1—wire谁接过两个的？
-----此内容被gthgth于2005-08-14,20:51:10编辑过

xiao_qi

北京 中发 8块多不开票

catayelo

21IC上的报价怎么是8块左右啊

master0722

我现在正在搞18B20，不过我现在是用M16的主芯片，因为可以JTAG仿真，程序弄好了我也发上来，和大家一起分享分享！！

lupinxjdl

北京 中发 ６．５元不开票　我购了５个

armok

这么便宜？



晕，上次我购了二十只，也要10元多。降价的原因是什么？

yangrufeng

请问楼主

     你的18B20的转化时间要750ms吗？好象默认是750，可你只延时200ms以上？怎么解释？

   我的显示如果是动态扫描的，扫描显示的时间就会很长，因为18B20转化的时间就要将近1S。

    你的init_1820();        //复位18b20

      write_1820(0xcc);   // 发出转换命令

      write_1820(0x44);

      delay(400);

      init_1820();

      WDR();

      write_1820(0xcc);  //发出读命令

      write_1820(0xbe);

      teml=read_1820();  //读数据

      temh=read_1820();

    中的delay(400); 随便定的吧。你最初是否显示85？我想应该是。

changjing

gthgth你是在哪买的？我也使天津的我在先驰买了几片13元/片，我还需要不少，在那里能买到10元以下的呀？

zhouyh

今天我也用18B20做了个温度计,12BIT,MC14489显示驱动,显示只精确到0.5度.正负温度都可以测量,用来测室外的温度.

Tang200858

DS18B20不能初始化，在初始化中判断while(PIND&(1<<6)) 为低电平，即QD为低电平时，程序不能运行。蔽闭while(PIND&(1<<6)) 后， temh=read_1820();  temph=temph&0x0f;

temph=15;不知道是什么原因。显示程序是自己编写的。单片机为M16，8M晶振，上拉电阻5.1K。
-----此内容被Tang200858于2005-11-28,11:12:21编辑过

voyager

用AVR还没搞过。不过用51倒是写过一个。而且连报警那步都给搞了。。。

原来就是返回一个64b的序列号。

qinsmy

各位DS18B20高手,今天我也编了个程序,但是运行起来LCD显示的是255.9,不知道什么原因,请哪位大老帮看一下,谢谢!







//DS18b20初始化

uchar DS18b20_reset(void)

{

   uint online;

   do

   {

   DDRD|=BIT(PD0);         // 设置DQ为输出

   //PORTD|=BIT(PD0);       //DQ置1

   PORTD&=~BIT(PD0);       //DQ置0         

    accuratedelay(240);      //延时482us 480---640us

        accuratedelay(240);

        accuratedelay(240);

        accuratedelay(240);

   PORTD|=BIT(PD0);        //DQ置1

   DDRD&=~BIT(PD0);        //设置DQ为输入

   //PORTD&=~BIT(PD0);       //DQ置0

   accuratedelay(138);          //70us      63--78 us

   //DDRD&=~BIT(PD0);        //设置DQ为输入

   online=PIND&0x01;

    }while(~online);       //响应信号

    accuratedelay(203);        //延时410us

        accuratedelay(203);

        accuratedelay(203);

        accuratedelay(203);

   return(online);          //返回0初始化成功,1则失败

}

//从单总线上读取一个字符

uchar read_byte(void)

{

    uchar i,mid;

        uchar value=0;

        for(i=8;i>0;i--)

         {

          value=value>>1;

      DDRD|=BIT(PD0);      // 设置DQ为输出

          PORTD&=~BIT(PD0);

          //delay_nus(6);     

          accuratedelay(10);       //6us  

          PORTD|=BIT(PD0);

          //delay_nus(9);      

          accuratedelay(16);       //9us

          DDRD&=~BIT(PD0);       //设置DQ为输入

          mid=PIND&0x01;

          if(mid)

             value|=0x80;

          //delay_nus(55);

          accuratedelay(108);       //55us

          }

          return(value);         

}



//向单总线上写一个字节

void write_byte(char val)

{

      uchar i,mid;

          for(i=8;i>0;i--)

            {

                DDRD|=BIT(PD0);      // 设置DQ为输出

                PORTD&=~BIT(PD0);

           // delay_nus(60);

                 accuratedelay(118);       //60us

                mid=val&0x01;

                if(mid)

                    PORTD|=BIT(PD0);

                else

                    PORTD&=~BIT(PD0);

                // delay_nus(10);

                accuratedelay(18);       //10us

                 PORTD|=BIT(PD0);

                 val=val/2;

                 }

                 //delay(90);

}

void Read_ROMCode(void)

{

int n;

//char dat[9];

//printf("
Reading ROM Code
");

while(DS18b20_reset());

delay_nms(250);

write_byte(0x33);

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

{

dat[n]=read_byte();

}

//printf("
ROM Code = %X%X%X%X
",dat[7],dat[6],dat[5],dat[4],dat[3],dat[2],dat[1],dat[0]);

}

void main(void)

{

      uchar k;

     port_init();

     init_devices();

     DDRA|=LCD_DATA;                     // 数据为输出

     DDRC|=LCD_RS|LCD_EN;                //置位RS.EN

     LCD_init();

         delay_nus(2);

         Read_ROMCode();

         while(DS18b20_reset());

         write_byte(0xCC);

         write_byte(0x44);

         delay_nms(300);

         write_byte(0xCC);

         write_byte(0xBE);

      teml=read_byte();               //读低字节数据

      temh=read_byte();               //读高字节数据

          temm_d=(teml&0x0f)*10/16;           //小数

      k=((teml>>4)&0x0f)+((temh<<4)&0xf0);                  //整数

      string[0]=k/100+0x30;                                  //百位

      k=k%100;                             

      temh_d=k/10;                                          //十位

      teml_d=k%10;                                          //个位

          string[1]=temh_d+0x30;

          string[2]=teml_d+0x30;

          string[4]=temm_d+0x30;

       

         LCD_write_string(4,0,"DS18B20");

         LCD_write_string(4,1,string);

}

space_time

用楼主的程序可以,

我把    "count=(temh*256+teml)*6.25;  //计算具体温度 "去掉了,

可以检测到温度,



只不过 零下温度转换正在试验!!!

sunfan198618

Ds18B20前几天去中发买的，7.5一个还是挺便宜的！呵呵！

sunlichao

吉林电子城卖10元一个

！

Rocker

选用mega8内部8M RC震荡和下面的设置有关吗？



OSCCAL=0X9d;//系统时钟校准，不同的芯片和不同的频率，

peterf

这个程序本人在PROTUES下仿真没有成功，不只是哪里的毛病 ！

hhrfjz

楼主的程序运行后读出的值怎么都是 0 阿？

okay51

昨天还在做18B20；我的也是显示0温度

希望有机会和各位讨论下

我用51写的 很郁闷 那个单线的对时序要求太高了 或者别的什么原因

那位做过51的，指点一下小弟好吗？我的程序在下面：

//温度传感器DS18B20的使用

//其中延时部分我都用proteus里的那个分析仪分析过了 延时长度在延时程序后面 精确的~~

//时序我已经检查了n遍

//温度算法我也不知道哪里错了

//可以确定硬件没问题 因为用另外一个程序可以正常显示!!!只是他的算法我不太喜欢 想做一个自己的~~~

//请众兄弟帮忙了



#include <reg52.h>

#include <intrins.h>



#define uchar unsigned char

#define uint  unsigned int



sbit DQ=P1^0;   //DS18B20的数据线

uchar cnt,n;        //定时器中断cnt次,采样一次温度,n是显示第n位数



uchar code  dottab[16]={0x00,0x01,0x01,0x02,0x03,0x03,0x04,0x04,//小数位显示值

                                                0x05,0x06,0x06,0x07,0x08,0x08,0x09,0x09};

uchar code segcode[10]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};          //0---9

uchar code bitcode[5] ={0x01,0x02,0x04,0x08,0x10};



//=============================================================================

bit ini18b20(void);                //初始化

uchar readdat(void);        //读数据

void wrdat(uchar dat);  //写数据

void tempcnt(void);            //温度处理



uchar data tempbuf[5]={0xff,0xc0,0xc0,0x40,0xc0};//温度缓存:符号位 三位整数,一位小数



//===============================================================================

//===============================================================================

void main(void)                                                                                                         

{

DQ=1;

TMOD=0x01;

TH0=0xf0;

TL0=0x60;

ET0=1;

TR0=1;

cnt=0;

n=0;



while(ini18b20()); //等待初始化完成

wrdat(0xcc);           //写CCH到DS18B20，以便跳过ROM匹配

wrdat(0x44);       //启动DS18B20进行温度转换



EA=1;

while(1) ;

}

//========定时器4ms中断服务程序4*200=0.8s检测温度一次.中断一次显示一位===========

void t0int(void) interrupt 1 using 1

{

TH0=0xf0;

TL0=0x60;

cnt++;

if(cnt==200)

        {

        cnt=0;

        TR0=0;

        tempcnt();           //调用温度处理程序

        TR0=1;

        }

P0=tempbuf[n];          //显示温度

P2=bitcode[n];

n++;

if(n==5) n=0;

}



//=================温度处理=====================================

void tempcnt(void)

{

bit f=0;

uchar t0,t1,tt;





while(ini18b20()); //等待初始化完成



wrdat(0xcc);

wrdat(0xbe);           //读暂存器9个字节内容

t0=readdat();

t1=readdat();



if(t1>0x80)

        {

        t1=~t1;

        if((~t0&0x80)!=((~t0+1)&0x80))t1=t1+1;

        t0=~t0+1;

        f=1;

        }           //判断是否负温度f=1为负温度标志



tt=(t1<<4)+(t0>>4);           //判断是否负温度f=1为负温度标志



tempbuf[4]=segcode[dottab[(t0&0x0f)]];           //小数位

tempbuf[3]=segcode[(tt%10)]&0x7f;                   //个位和小数点

tempbuf[2]=segcode[(tt/10)%10];                           //十位

tempbuf[1]=segcode[tt/100];                                   //百位

if(f==1)

        tempbuf[0]=0xbf;                                           //符号位

else

        tempbuf[0]=0xff;



while(ini18b20()); //等待初始化完成

wrdat(0xcc);           //写CCH到DS18B20，以便跳过ROM匹配

wrdat(0x44);       //启动DS18B20进行温度转换

}

//==============================================初始化DS18B20        :硬件复位检查

bit ini18b20(void)

{

bit xx;

uchar i;

DQ=1;

for(i=20;i>0;i--);

DQ=0;

for(i=255;i>0;i--) ;                // 520us

DQ=1;

for(i=15;i>0; i--) ;                //40us

xx=DQ;

for(i=60;i>0;i--) ;                        //120us

DQ=1;

return (xx);                        //返回值:如果=0则初始化成功 =1则初始化失败

}

//===============================================读出数据

uchar readdat(void)

{

uchar i,j;

uchar dat=0;

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

        {

        dat=dat>>1;

        DQ=0;                                        // 拉低总线

        _nop_();

        DQ=1;                                        //释放总线

        _nop_();_nop_();

        _nop_();_nop_();

        if(DQ)  dat=dat|0x80;

                else  dat=dat|0x00;

        for(j=20;j>0;j--);    //50us

        }

return(dat);

}



//===========================向DS18B20写数据

void wrdat(uchar dat)

{

uchar i,j;

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

        {

        if(dat&0x01==0)

                {

                DQ=0;

                for(j=30;j>0; j--) ;  //80us

                DQ=1;

                 }

        else

                {

                DQ=0;

                _nop_();_nop_();

                DQ=1;

                for(j=30;j>0;j--);           //78us

                }

        dat=dat>>1;

        _nop_();

        }

}

nk714

刚搞的很简单的 只能读温度  而且没处理0下呢  0下应该就检测符号位  处理下数据的吧

A8单片机  内部RC设置为8M  软件ICC 6.31  PCO为数据端  t为读出的温度数据 显示程序调用T并转化为10进制显示就可以  更多功能我们一起讨论做出来吧。我尽量写了我自己的理解说明，有什么不对的请大家指教。

程序如下：

//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH//

      

#include<iom8v.h>                      //包含定义ATmega8寄存器的头文件

#include<macros.h>                     //包含一些常用的宏定义

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx                       

void delay(int i)                //定时程序          1.5us左右

{

while(i>=0)

  {i--;}

}

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

void delay500(int j)                //长延时  约0.5MS

{int k=500;

while(j>=0)

  {

   while(k>=0)

   {k--;}

   k=1000;

   j--;

  }

}



//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

//复位程序

int reset()

{

int test=0;                                        //定义返回值 0成功 1失败

DDRC=0XFF;                                        //设置数据线口为输出状态

PORTC=0xfe;                                        //拉低总线 准备复位

delay(400);                                        //延时600us

PORTC=0xff;                                        //释放总线

delay(60);                                        //等待60us 准备接受器件存在信号

DDRC=0x00;                                        //数据口设置为输入

test=PINC;                                        //接收器件返回的复位信号

delay(500);                                        //等待480us完成复位

test&=0x01;                                        //处理返回信号成一位数据

DDRC=0XFF;                                        //数据口设置为输出

PORTC=0XFF;                                        //输出高电平 释放总线

return test;

}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

//写一比特

void write(int bit)

{int i=8;                                       //循环8次写一字节

for(i=8;i>0;i--)

  {DDRC=0XFF;                                               //设置为输出

   PORTC=0X00;                                        //拉低总线 开始准备写数据

   delay(3);                                        //等待4us

   PORTC=0XFF;                                        //释放总线

   delay(12);                                        //延时15us

   PORTC=bit&0x01;                                 //写数据

   delay(70);                                        //等待60us 18B20采集数据

   DDRC=0XFF;                                        //释放总线

   PORTC=0XFF;

   bit=bit>>1;                                        //数据**右移位** 先发低位

  }  

}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

//读一字节

int read(void)

{int i,temp=0,bit=0;

for(i=0;i<8;i++)                                //循环8次读一字节

  {

   DDRC=0Xff;                                         //设置输出准备读数据                                                                          

   PORTC=0x00;                                        //拉低总线 开始读时间隙

   delay(2);                                        //等待3us

   PORTC=0XFF;                                        //释放总线

   delay(2);                                        //等待3us

   DDRC=0x00;                                        //数据口设置为输入

   delay(1);                                       

   temp=PINC;                                        //接收数据

   delay(80);                                        //等待60us完成读周期

   temp<<=7;

   temp&=0x80;                                   //接收数据转化为位数据

   DDRC=0XFF;                                        //释放总线

   PORTC=0XFF;

   bit=bit>>1;                                        //数据**右移位，先接受高位

   bit=bit|temp;                                //转化为并行数据

  }  

  return bit;

}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

//显示程序

void led(unsigned long int BCDdata)

{

char led[8]={0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe};//位选缓冲区

int leddata[8];//数据缓冲区***跟随显示位数变化而变化

int ledtable[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};//段码列表

unsigned long int data;//临时数据

int y=100,i;//循环变量  ****Y满足18B20转换所需要的500ms**

DDRD=0Xff;  //PD口设置为段码输出

DDRB=0Xff;  //PB口设置为数据输出

PORTD=0xff; //显示消隐

PORTB=0xff; //显示消隐



//数据转换成十进制显示值

while(y>=0)

{

  data=BCDdata;

  for(i=0;i<8;i++)      //刷新显示缓冲区

    {   

     leddata=ledtable[data%10];//16位数据转10进制数据

     data=data/10;

     leddata[0]&=0x7f;  //设置小数点  

         

     PORTD=led;      //0X7F;//显示第i位

     PORTB=leddata;        //发送要显示的数据

     delay500(1);       //延时1ms

     PORTB=0XFF;

    }       

  y--;                         

}  

}  

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx



void main()

{int test=0,k=0;                //复位返回 和9直接读取循环变量

int m,n,t;                     //临时数据

int da[9]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};//定义数据缓冲区

while(1)

{

  reset();                        //复位                                                                  

  write(0xcc);                            //发送不提供ROM编码命令                                                                          

  write(0x44);                      //发送开始转换命令

  led(t);                         //循环显示500ms以完成温度转换

  

  reset();                      //复位 准备读数据

  write(0xcc);                        //发送不提供ROM编码命令

  write(0xbe);                         //发送读数据命令

  for(k=0;k<=8;k++)                //循环读9个字节的数据 并存储进数据缓冲区

  {

   test=read();

   da[k]=test;                         //9字节数据依次读入数据缓冲区

  }



  reset();                            //复位 下面开始数据转换成温度值

  m=da[0];                        //度读温度低位数据

  n=da[1];                         //读温度高位数据

  n=n<<8;                                 //数据整合为16位数据

  m=m|n;

  t=(m*0.0625);                        //计算实际温度值 t为温度数据

}

}

lychee420

１８Ｂ２０　的精度高哦，可就是浪费时间哦！

我也写了一个程序哦

用的　Ｍ８　８Ｍ的晶振！很好用哦！

注：对它读数据的时候，等待的时间不要太久哦，要不读出来的就是全为一！

lychee420

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

*  文件名称：18b20.c

*  功    能：读取18B20的温度

*  时    间：2006.8.1

*  端口使用：PD4（DQ）

   说    明：晶振：8MHz

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

#include <iom8v.h>

#include <macros.h>





#define xtal  8                      //1MS

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

*   函数名称：void DelayUS(unsigned int time)

*   功    能：软件延时1.1Us

*   入口参数：time 延时时间

*   出口参数：无

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

void DelayUS(unsigned int time)

{   

     while(time>1)

            time--;

}

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

*   函数名称：void DelayMS(unsigned int time)

*   功    能：软件延时  1/1000s

*   入口参数：time 延时时间 MS  

*   出口参数：无

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

void DelayMS (unsigned int time)

{

    unsigned int i;

    while(time--)       

        {

          for(i=1;i<(unsigned int)(xtal*143-2);i++)

              ;

        }  

}



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

*   函数名称：unsigned char Check18B20(void)

*   功    能：检查18B20是否存在

*   入口参数：无

*   出口参数：检查存在是返回 0

                不存在是返回 1

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

unsigned char Check18B20(void)

{

    unsigned char signal;

       

        DDRD |= 0x08;

        PORTD&= 0xF7;   //PD3输出低电平 ，复位18B20

        DelayUS(436);   //延时480US

       

        PORTD|= 0x08;    //PD3输出高

        DDRD |= 0x08;   //PD3输入

        DelayUS(57);   //延时63US

        while(PIND & 0x08)

            signal = 0;  //读取PD3的值,也就是18B20输出的值

       

        DelayUS(181);   //延时200US

        return signal;

}                               

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

*   函数名称：unsigned char Read18B20(void)

*   功    能：从18B20读一个字节的数据

*   入口参数：无

*   出口参数：读出的数据

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

unsigned char Read18B20(void)

{

    unsigned int byte=0,i;

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

        {

            DDRD |= 0x08;

                PORTD&= 0xF7;   //总线为低电平

                asm("nop");

                asm("nop");

                asm("nop");

               

                PORTD|= 0X08;   //总线为高电平

                asm("nop");

                asm("nop");

                DDRD &= 0xf7;   //PD3端口输入

                PORTD|= 0X08;

        //DelayUS(1);

                if((PIND & 0x08)==0x08)

                {

                    byte |= (0x01<<i);    //先读高位的值

                }

                DelayUS(37);          // delay 55us

        }

        return byte;

}



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

*   函数名称：void Write18B20(unsigned char cmd)

*   功    能：向18B20写入一个字节的数据

*   入口参数：要写入的数据或者是字节

*   出口参数：无

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

void Write18B20(unsigned char cmd)

{

    unsigned int i ;

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

        {

            DDRD |= 0x08;

                if(cmd & 0x01)

                {

                    PORTD |= 0X08;   

                        PORTD &= 0XF7;   //高……》低

                       

                    DelayUS(10);     //delay 15us

                        PORTD |= 0x08;   //高

                        DelayUS(37);     //  延时56us

                }

                else

                {   

                        PORTD &= 0XF7;  //高……》低

                       

                    DelayUS(40);    //延时60us

                        PORTD |= 0x08;

                        DelayUS(5);

                }

                cmd = cmd>>1;

        }

}

/************************** main()******************************/

void main(void)

{

    unsigned int i=0,n=0;

    unsigned int temph=0 ,templ=0;

        unsigned int ds18b20_temp=0;

       

          

        while(0x00 != Check18B20()) //检查18b20是否存在

            ;

        Dis_Data(1);

   　　　Write18B20(0xcc);               

        Write18B20(0x44);  //启动转换

        DelayMS(200);       //200MS

        while(0x00 != Check18B20()) //检查18B20是否存在，复位

            ;

        Write18B20(0xcc);

   　　　　Write18B20(0xbe);  //读取温度值

       

        templ = Read18B20();

        temph = Read18B20();

        ds18b20_temp = temph<< 8;

        ds18b20_temp |=templ;

        while(1)

        {  

            Dis_Data(ds18b20_temp*0.0625);

    }

}

huangfan

能不能发一个带crc校验的18B20程序呀!

weety

DS18B20哈尔滨船舶电子大世界卖８元

zhshliu

贴一个判断零上和零下温度判断的程序部分.

flag为零下标志,1为零下,此标志可做显示时负号的显示标志;

count为unsigned int或unsigned long型,为最终温度值的10倍

当前温度数据处理后只能得到0.1度的数据,如要得到0.0625精度的数据,只需将*6.25那改成*625即可,因为count做整型处理,小数点后数据被截掉.

此程序为GCC 程序.



if((temh&0xF8) == 0xF8)

{

        flag=1;

        count=((0xFF-temh)*256+(0xFF-teml))*6.25;

        //count=((0xFF-temh)*256+(0xFF-teml))*625;

}

else

{       

        flag=0;

        count=(temh*256+teml)*6.25;

        //count=(temh*256+teml)*625; //计算具体温度

}

pushifan

我在２０００年做了一个使用１８Ｂ２０的程序，去年又做了一个温度控制的项目，现将程序发上来与大家分享，不过我正在学习ＡＶＲ还没有ＡＶＲ开发能力，所以程序是c51的．有兴趣的可以改为ＧＣＣ．



//温度读取（１８Ｂ２０）、LCD显示（１２８*６４）

//时间 2005.12.4

//LCD改用12864R，具有4段时间

//增加74ls574控制继电器，所有元件放在电路板上。//增加看门狗复位找回功能//增加74hc245

#pragma  DEBUG CODE               

#include <c:\C51\INC\reg52.h>        /* define 8052 registers */

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

#define SDA       P10

#define SCL       P11

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

#define dat_1820   P12

#define S2   P13

#define S3   P14

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

#define        RS          P37 //LCD指令/数据

#define        RW           P15 //LCD读/写

#define        E1          P31 //LCD复位

#define        EE          P30 //LCD复位

#define        BF        P07

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

#define        KEY1    P20

#define        KEY2    P21

#define KEY3    P22

#define        KEY4    P33

#define        KEY5    P34

#define        No_warter    P36

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

#define        SPEAK      P17       

#define MAX813_WDI P16



typedef unsigned char uchar;



uchar code num_MODE[10] =

{

0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39

};

uchar code setup[46] =

{

0xca,0xb1,0xbc,0xe4,0xb5,0xf7,0xd5,0xfb,0xc7,0xeb,0xb0,0xb4,0xa3,0xad,0xbc,0xfc,

0xb2,0xce,0xca,0xfd,0xc9,0xe8,0xd6,0xc3,0xc7,0xeb,0xb0,0xb4,0xa3,0xab,0xbc,0xfc,

0xcd,0xcb,0xb3,0xf6,0xc7,0xeb,0xb0,0xb4,0xc9,0xe8,0xd6,0xc3,0xbc,0xfc

};

uchar code stnum[32]={1,0,7,0,35,50,25,30,10,0,11,0,35,50,25,30,13,0,14,0,35,50,25,30,17,0,21,0,35,50,25,30};

uchar code dot[4]={0x00,0x0C,0x0C,0x00,};

uchar code buffer1[16]={0,0,1,1,2,3,3,4,5,5,6,6,7,8,8,9};

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

void        dl_us(unsigned int count);

void        dl_ms(unsigned int count);

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

uchar   rst(void);

bit     rdbit(void);

void    wtbyte(uchar dat);

void    tempst(void);

uchar   rdtemp(void);

void        FIR_mrd1820(void);

uchar   rst2(void);

bit     rdbit2(void);

void    wtbyte2(uchar dat);

void    tempst2(void);

uchar   rdtemp2(void);

void        FIR_mrd18202(void);

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



void        BUZER_SUB(void);

void        ext_1(void);        // interrupt 2;

void        Timer_0(void);  // interrupt 1;

void         SCAN_KEY(void);

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

void revdata(void);

void senddata(void);

void load_time(void);

void load_temp(void);

void WT_TEMP(uchar fstadrm);

void WT_CHIP(uchar fstadrt);

void RD_CHIP(uchar fstadrp);

void WT_8583_TM(void);                //;向8583_RAM区中写特殊码

void RD_TM(void);                //特殊码

void RAM_TM(void);      

void initial();

uchar Duan_CNT, B_DAY;

uchar BK_ADDR;

bit ack,F_rise;

bit RL1,RL2,RL3,RL4,RL5;

bdata uchar com_data=0,l;

sbit cos_bit=com_data^7;

sbit low_bit=com_data^0;

uchar slvadr,subadr,bytecnt;

uchar senrev[6]={0,0,0,0,0,0};

uchar temp[4],shift_cnt;

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

void        LCDBUSY        (void); //判断LCD是否正在工作

void        WRCOM        (char showctl);

void        WRDATA        (char showctl);

void    Lcd_init(void); //LCD初始化

void         Clear_LCD(void);

void display1(void);

void display2(void);

void display3(void);

void display4(void);

void fd(void);

void tov(void);

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

uchar        buff_last;

uchar        idata TIME_REAL_h;      //实时时钟 小时 BCD码 23点

uchar        idata TIME_REAL_m;        //实时时钟 分钟 BCD码 59分

uchar        idata Temp_onw,Temp_offw;      

uchar        idata Temp_onr,Temp_offr;

unsigned int idata Time_on,Time_off;



bit     TEMP_SIGN,F_control,F_hand,F_working,F_work_off;

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

unsigned int B_T1s=400,B_Txs=10;

bit F_T1s,F_Txs,F_flash;

bit F_new,F_cros_disp;

uchar idata RAM_i,segm;

uchar data buffer[8];

void Duan_set(void);

void         SCAN_KEY(void);

void control_sub(void);

void contronl(void);

void pump_on(void);

void pump_off(void);

void QDJCZ(void);

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

void main ()

{

  P26=1;

  P31=0;

  B_Txs=10;

  //Duan_set();

  F_new=0;

  P0=0X00;

  QDJCZ();

  RL1=RL2=RL3=RL4=RL5=0;

  F_working=0;

  F_work_off=1;

  Lcd_init();

  initial();

  FIR_mrd1820();

  FIR_mrd18202();

  P31=1;

  display2();

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

  for( RAM_i=0;RAM_i<6;RAM_i++)

    {   RD_CHIP((0x70+RAM_i));

          if(senrev[0]!=0XAA)

               { WT_8583_TM();

                 for( l=0;l<32;l++)

              {  

                    senrev[0]=stnum[l];

                    WT_CHIP(0x20+l);

               }

           }

     }

  RAM_i=0;

  dl_us(10);

  BUZER_SUB();

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

  while(1)

  {   

     MAX813_WDI=0;   

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

     if(KEY1==0)

       {F_hand=~F_hand;

        Clear_LCD();

        if(F_hand)

        {F_new=0;

         Duan_set();// Temp_onw;Temp_offw;Temp_onr;Temp_offr;//Time_on,Time_off;

         }

         else

         {

          Temp_onr=Temp_offr=Time_on=Time_off=Temp_offw=0;

          while(!F_work_off)//如果未关机则执行关机

               { MAX813_WDI=0;

                 FIR_mrd1820();

                 FIR_mrd18202();

                 display2();

                 pump_off();

                 }

         }

        dl_ms(20);

        while(KEY1==0)        MAX813_WDI=0;

        dl_ms(20);

         }

     //***********KEY1********************

      if(F_hand)

       {

         control_sub();

         MAX813_WDI=0;

         FIR_mrd1820();

         FIR_mrd18202();

         tov() ;

         display2();

         }

      else

      {

        //*************防冻处理*****************

       fd();

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

       MAX813_WDI=0;

       display2();

       dl_us(10);

      }

          //Clear_LCD();

      }

}//主控程序结束。

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



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

void QDJCZ(void)

{

  P24=0;

  P23=0;

  P23=1;

}

void initial()

{

  TMOD=0X02;

  TL0=0X06;

  TH0=0X06;

  TR0=1;

  PT0=1;

  ET0=1;

  EX0=1;

  EX1=1;

  EA=1;

  MAX813_WDI=0;       

}

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

void control_sub(void)

{ uchar temptemw,temptemr;

  unsigned int time0,time1,time2,time3,time4;

  if(No_warter)

   {

     RD_CHIP(0x03);

     time0=(((senrev[1]>>4)*10+(senrev[1]&0x0f))*256+(senrev[0]>>4)*10+(senrev[0]&0x0f));

     if(F_new==0)//初次上电

       {

          if((Time_on<=time0)&&(time0<Time_off))

              {

                F_control=1;

               }

        }

     if(Time_on==time0)

           {

            F_control=1;

           }

     if(Duan_CNT==1)

         {

          RD_CHIP(0x03);

          time0=(((senrev[1]>>4)*10+(senrev[1]&0x0f))*256+(senrev[0]>>4)*10+(senrev[0]&0x0f));

          if(Time_off==time0)

           {

            Duan_CNT=2;

            F_control=0;

            RD_CHIP(0x28);

            Time_on=senrev[0]*256+senrev[1];

            RD_CHIP(0x2a);

            Time_off=senrev[0]*256+senrev[1];

            RD_CHIP(0x2c);

            Temp_onw=senrev[0];

            Temp_offw=senrev[1];

            RD_CHIP(0x2e);

            Temp_onr=senrev[0];

            Temp_offr=senrev[1];

            }

           if(F_control)

             {

              contronl();

              }

           else

             {

              while(!F_work_off)

               { MAX813_WDI=0;

                 FIR_mrd1820();

                 FIR_mrd18202();

                 display2();

                 pump_off();

                 }

             }

          }

       else if(Duan_CNT==2)

         {

          RD_CHIP(0x03);

          time0=(((senrev[1]>>4)*10+(senrev[1]&0x0f))*256+(senrev[0]>>4)*10+(senrev[0]&0x0f));

          if(Time_off==time0)

           {

            Duan_CNT=3;

            F_control=0;

            RD_CHIP(0x30);

            Time_on=senrev[0]*256+senrev[1];

            RD_CHIP(0x32);

            Time_off=senrev[0]*256+senrev[1];

            RD_CHIP(0x34);

            Temp_onw=senrev[0];

            Temp_offw=senrev[1];

            RD_CHIP(0x36);

            Temp_onr=senrev[0];

            Temp_offr=senrev[1];

            }

           if(F_control)

             {

              contronl();

              }

           else

             {

              while(!F_work_off)

               {MAX813_WDI=0;

                 FIR_mrd1820();

                 FIR_mrd18202();

                 display2();

                 pump_off();

                 }

             }

            }

          else if(Duan_CNT==3)

         {

          RD_CHIP(0x03);

          time0=(((senrev[1]>>4)*10+(senrev[1]&0x0f))*256+(senrev[0]>>4)*10+(senrev[0]&0x0f));

          if(Time_off==time0)

           {

            Duan_CNT=4;

            F_control=0;

            RD_CHIP(0x38);

            Time_on=senrev[0]*256+senrev[1];

            RD_CHIP(0x3a);

            Time_off=senrev[0]*256+senrev[1];

            RD_CHIP(0x3c);

            Temp_onw=senrev[0];

            Temp_offw=senrev[1];

            RD_CHIP(0x3e);

            Temp_onr=senrev[0];

            Temp_offr=senrev[1];

            }

           if(F_control)

             {

              contronl();

              }

           else

             {

              while(!F_work_off)

               {MAX813_WDI=0;

                 FIR_mrd1820();

                 FIR_mrd18202();

                 display2();

                 pump_off();

                 }

             }

          }

        else if(Duan_CNT==4)

         {

          RD_CHIP(0x03);

          time0=(((senrev[1]>>4)*10+(senrev[1]&0x0f))*256+(senrev[0]>>4)*10+(senrev[0]&0x0f));

          if(Time_off==time0)

           {

            Duan_CNT=1;

            F_control=0;

            RD_CHIP(0x20);

            Time_on=senrev[0]*256+senrev[1];

            RD_CHIP(0x22);

            Time_off=senrev[0]*256+senrev[1];

            RD_CHIP(0x24);

            Temp_onw=senrev[0];

            Temp_offw=senrev[1];

            RD_CHIP(0x26);

            Temp_onr=senrev[0];

            Temp_offr=senrev[1];

            }

           if(F_control)

             {

              contronl();

              }

           else

             {

              while(!F_work_off)

               {MAX813_WDI=0;

                 FIR_mrd1820();

                 FIR_mrd18202();

                 display2();

                 pump_off();

                 }

             }

            }

    }

  else //No_warter=0

   {   

   

    while(!F_work_off)

       {

         switch(RAM_i)

          {

          case 0:  

               P0=0Xe1;//

               QDJCZ();

               RL2=RL3=RL4=RL5=0;

               B_Txs=720;

               F_Txs=0;

               RAM_i+=1;

              break;

           case 1:  

              if(F_Txs)

              {

               P0=0Xe0;//

               QDJCZ();

               RL1=0;   

               F_Txs=0;

               RAM_i=0;

               F_working=0;

               F_work_off=1;

               }

              break;

            }

         MAX813_WDI=0;

         display2();

         }

     while(!No_warter) //*********************缺水报警*********

         {    Clear_LCD();

              WRCOM(0x90);

              WRCOM(0x90);

              WRDATA(0xbe);WRDATA(0xaf);

              WRDATA(0xb8);WRDATA(0xe6);

              WRDATA(0xa1);WRDATA(0xc3);

              

              WRDATA(0xc8);WRDATA(0xb1);

              WRDATA(0xcb);WRDATA(0xae);

              WRDATA(0xa3);WRDATA(0xa1);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                Clear_LCD();

                if(KEY1==0)

                 {F_hand=~F_hand;

                  dl_ms(20);

                  while(KEY1==0)        MAX813_WDI=0;

                  dl_ms(200);

                  break;

                 }

                //*********

         }   

    }

}

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

void contronl(void)

{           uchar temptemw,temptemr;

            FIR_mrd1820();//buffer[0];buffer[1];buffer[2];

            temptemw=buffer[0]*10+buffer[1];

            FIR_mrd18202();//buffer[3];buffer[4];buffer[5];buffer[6];buffer[7];

            temptemr=buffer[3]*10+buffer[4];

            MAX813_WDI=0;

            MAX813_WDI=0;

            if(F_new==0)//初次上电

             {

              if((temptemr<Temp_offr)&&(temptemw<Temp_offw))

               {

                while(!F_working)

                 {MAX813_WDI=0;

                 //FIR_mrd1820();

                 //FIR_mrd18202();

                 display2();

                 pump_on();

                 }

               }

              }

           else

            {

             if((temptemr<Temp_onr)&&(temptemw<Temp_onw)&&(!F_working))

               {

               while(!F_working)

               { MAX813_WDI=0;

                 //FIR_mrd1820();

                 //FIR_mrd18202();

                 display2();

                 pump_on();

                 }

               }

             if(((Temp_offr<=temptemr)||(Temp_offw<=temptemw))&&(F_working))

              {

               while(!F_work_off)

               { MAX813_WDI=0;

                 //FIR_mrd1820();

                 //FIR_mrd18202();

                 display2();

                 pump_off();

                 }

               }

             }

}

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

void pump_off(void)

{     

MAX813_WDI=0;

F_rise=0;

switch(RAM_i)

        {

          case 0:

               P0=0XFD;//

               QDJCZ();

               RL2=0;//第一组停

               B_Txs=40;

               F_Txs=0;

               RAM_i+=1;

              break;

           case 1:  

              if(F_Txs)

              {

               P0=0XF9;//

               QDJCZ();

               RL3=0;    //第二组停

               F_Txs=0;

               B_Txs=40;

               RAM_i+=1;

               }

              break;

            case 2:  

              if(F_Txs)

              {

               P0=0XF1;//

               QDJCZ();

               RL4=0;//第三组停

               F_Txs=0;

               B_Txs=40;

               RAM_i+=1;

              }

              break;

            case 3:  

              if(F_Txs)

              {

               P0=0Xe1;//

               QDJCZ();

               RL5=0;//第二组停

               F_Txs=0;

               B_Txs=180;

               RAM_i+=1;

              }

              break;

            case 4:  

              if(F_Txs)

              {

               P0=0Xe0;//

               for(BK_ADDR=0;BK_ADDR<=10;BK_ADDR++){BK_ADDR=BK_ADDR;}

               QDJCZ();

               for(BK_ADDR=0;BK_ADDR<=10;BK_ADDR++){BK_ADDR=BK_ADDR;}

               RL1=0;//电机停

               RAM_i=0;

               F_working=0;

               F_work_off=1;

              }

              break;

         }

}

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

void pump_on(void)

{              

MAX813_WDI=0;

F_rise=1;         

switch(RAM_i)

        {

          case 0:

               P0=0X01;//

               for(BK_ADDR=0;BK_ADDR<=10;BK_ADDR++){BK_ADDR=BK_ADDR;}  

               QDJCZ();

               for(BK_ADDR=0;BK_ADDR<=10;BK_ADDR++){BK_ADDR=BK_ADDR;}

               RL1=1;//电机接通

               B_Txs=120;

               F_Txs=0;

               RAM_i+=1;

              break;

           case 1:  

              if(F_Txs)

              {

               P0=0X03;//

               QDJCZ();

               RL2=1;    //第一组接通

               F_Txs=0;

               B_Txs=40;

               RAM_i+=1;

               }

              break;

            case 2:  

              if(F_Txs)

              {

               P0=0X07;//

               QDJCZ();

               RL3=1;//第二组接通

               F_Txs=0;

               B_Txs=40;

               RAM_i+=1;

              }

              break;

            case 3:  

              if(F_Txs)

              {

               P0=0X0f;//

               QDJCZ();

               RL4=1;//第二组停

               F_Txs=0;

               B_Txs=40;

               RAM_i+=1;

              }

              break;

            case 4:  

              if(F_Txs)

              {

               P0=0X1f;//

               QDJCZ();

               RL5=1;//第二组停

               F_Txs=0;

               RAM_i=0;

               F_new=1;

               F_working=1;

               F_work_off=0;

              }

              break;

         }

}

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

void Duan_set(void)

{   

   unsigned int time0,time1,time2,time3,time4,time5,time6,time7,time8;

   

    MAX813_WDI=0;

    RD_CHIP(0x03);

    time0=(((senrev[1]>>4)*10+(senrev[1]&0x0f))*256+(senrev[0]>>4)*10+(senrev[0]&0x0f));

   

    RD_CHIP(0x20);

    time1=senrev[0]*256+senrev[1];

    RD_CHIP(0x22);

    time2=senrev[0]*256+senrev[1];//senrev[0];

   

    RD_CHIP(0x28);

    time3=senrev[0]*256+senrev[1];

    RD_CHIP(0x2a);

    time4=senrev[0]*256+senrev[1];//senrev[0];

   

    RD_CHIP(0x30);

    time5=senrev[0]*256+senrev[1];

    RD_CHIP(0x32);

    time6=senrev[0]*256+senrev[1];

   

    RD_CHIP(0x38);

    time7=senrev[0]*256+senrev[1];

    RD_CHIP(0x3a);

    time8=senrev[0]*256+senrev[1];//senrev[0];

           

    MAX813_WDI=0;

    if( ((time1<time0)&&(time0<time2))||(((time8<=time0)&&(time0<9216))||(time0<=time1)))//time1---time2

        {

          Duan_CNT=1;

          Time_on=time1;

          Time_off=time2;

          RD_CHIP(0x24);

          Temp_onw=senrev[0];

          Temp_offw=senrev[1];

          RD_CHIP(0x26);

          Temp_onr=senrev[0];

          Temp_offr=senrev[1];

         }

      else if((time3<time0)&&(time0<time4)||((time2<=time0)&&(time0<=time3)))//time3--24  24---time4

         { Duan_CNT=2;

           Time_on=time3;

           Time_off=time4;

           RD_CHIP(0x2c);

           Temp_onw=senrev[0];

           Temp_offw=senrev[1];

           RD_CHIP(0x2e);

           Temp_onr=senrev[0];

           Temp_offr=senrev[1];

          }

       else if((time5<time0)&&(time0<time6)||((time4<=time0)&&(time0<=time5)))//time5---time6

          {

          Duan_CNT=3;

          Time_on=time5;

          Time_off=time6;

          RD_CHIP(0x34);

          Temp_onw=senrev[0];

          Temp_offw=senrev[1];

          RD_CHIP(0x36);

          Temp_onr=senrev[0];

          Temp_offr=senrev[1];

           }

        else if((time7<time0)&&(time0<time8)||((time6<=time0)&&(time0<=time7)))//time5---time6

          {

          Duan_CNT=4;

          Time_on=time7;

          Time_off=time8;

          RD_CHIP(0x3c);

          Temp_onw=senrev[0];

          Temp_offw=senrev[1];

          RD_CHIP(0x3e);

          Temp_onr=senrev[0];

          Temp_offr=senrev[1];

           }

         else

          {Duan_CNT=0;

           B_DAY=0;

           }

}

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

void tov(void)  

{    uchar temptemw;

      FIR_mrd1820();//buffer[0];buffer[1];buffer[2];

      temptemw=buffer[0]*10+buffer[1];  

              if(temptemw>=75)

               {

                Clear_LCD();

               

                WRCOM(0x90);WRCOM(0x90);

               

                WRDATA(0xbe);WRDATA(0xaf);

                WRDATA(0xb8);WRDATA(0xe6);

                WRDATA(0xa1);WRDATA(0xc3);

               

                WRDATA(0xcb);WRDATA(0xae);

                WRDATA(0xce);WRDATA(0xc2);

               

                WRDATA(0xb9);WRDATA(0xfd);

                WRDATA(0xb8);WRDATA(0xdf);

               

                WRDATA(0xa3);WRDATA(0xa1);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

               

                Clear_LCD();

               }

  }

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

void fd(void)

{      

uchar temptemw,temptemr;

            FIR_mrd1820();//buffer[0];buffer[1];buffer[2];

            temptemw=buffer[0]*10+buffer[1];

            FIR_mrd18202();//buffer[3];buffer[4];buffer[5];buffer[6];buffer[7];

            temptemr=buffer[3]*10+buffer[4];

            MAX813_WDI=0;

           

            if((temptemr<=5)&&(!F_working))

               {

               while(!F_working)

               {MAX813_WDI=0;

                 //FIR_mrd1820();

                 //FIR_mrd18202();

                 display2();

                 pump_on();

                 }

               }

             if((10<=temptemr)&&(F_working))

              {

               while(!F_work_off)

               {MAX813_WDI=0;

                 //FIR_mrd1820();

                 //FIR_mrd18202();

                 display2();

                 pump_off();

                 }

               }

}

//****键盘设置**************************

ext_1() interrupt 2  

{

uchar k1,t1,t2,t3,t4;  

EX1=0;                // 进中断程序后就关掉外中断1，改为查询方式

MAX813_WDI=0;

ET0=1;         

TR0=1;

B_Txs=120;

F_Txs=0;

Clear_LCD();

WRCOM(0x80);

WRCOM(0x0c);

for(k1=0;k1<16;k1++)

        {

         WRDATA(setup[k1]);

        }

WRCOM(0x90);

for(k1=16;k1<32;k1++)

        {

         WRDATA(setup[k1]);

        }

WRCOM(0x88);

for(k1=32;k1<46;k1++)

        {

         WRDATA(setup[k1]);

        }

k1=0;

BUZER_SUB();

while(KEY4==0)        //首次进入中断 判FUNC键是否抬起

        {   MAX813_WDI=0;

         }

dl_ms(100);

MAX813_WDI=0;

while(1)

{    MAX813_WDI=0;         

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

     if(KEY2==0)//时间设置

       {B_Txs=120;

        shift_cnt=0;

        BUZER_SUB();

        Clear_LCD();

        RD_CHIP(0x03);

        buffer[3]=senrev[1]>>4;

        buffer[2]=senrev[1]&0x0f;

        buffer[1]=senrev[0]>>4;

        buffer[0]=senrev[0]&0x0f;

        display3();

        dl_ms(20);

        while(KEY2==0) MAX813_WDI=0;       

        while(1)

         {

          if(KEY5==0)//时间设置

           {B_Txs=120;

            shift_cnt+=1;

            if(shift_cnt>1)

              {

               shift_cnt=0;

              }

             BUZER_SUB();       

             while(KEY5==0) MAX813_WDI=0;

            }

           switch(shift_cnt)

             {

              case 0:  

              WRCOM(0x95);

              WRDATA(num_MODE[buffer[1]]);

              WRDATA(num_MODE[buffer[0]]);

              WRCOM(0x95);

              WRCOM(0x0d);

              if(KEY3==0) //时间加

               {buffer[0]+=1;B_Txs=120;

                if(buffer[0]>9)

                 {

                   buffer[0]=0;

                   buffer[1]+=1;

                   if(buffer[1]>5)

                    {

                     buffer[1]=0;

                     }

                 }

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

               if(KEY2==0) //时间加

               {B_Txs=120;

                if((buffer[0]==0)&&(buffer[1]==0))

                 {

                   buffer[0]=9;

                   buffer[1]=5;

                   }

                 else if((buffer[0]==0)&&(buffer[1]!=0))

                    {

                     buffer[0]=9;

                     buffer[1]-=1;

                     }

                 else

                   {

                    buffer[0]-=1;

                   }

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

              break;

              case 1:

              WRCOM(0x93);

              WRDATA(num_MODE[buffer[3]]);

              WRDATA(num_MODE[buffer[2]]);

              WRCOM(0x93);

              WRCOM(0x0d);

              if(KEY3==0) //时间加

               {buffer[2]+=1;B_Txs=120;

                if((buffer[3]==2)&&(buffer[2]>=4))

                   {

                    buffer[3]=0;

                    buffer[2]=0;

                    }

                if(buffer[2]>9)

                 {

                   buffer[2]=0;

                   buffer[3]+=1;

                   }

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

               if(KEY2==0) //时间加

               {B_Txs=120;

                if((buffer[2]==0)&&(buffer[3]==0))

                 {

                   buffer[2]=3;

                   buffer[3]=2;

                   }

                 else if((buffer[2]==0)&&(buffer[3]!=0))

                    {

                     buffer[2]=9;

                     buffer[3]-=1;

                     }

                 else

                   {

                    buffer[2]-=1;

                   }

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

              break;

              }

          if(F_Txs)

           {

            senrev[0]=(buffer[1]<<4)|buffer[0];

            WT_CHIP(0x03);

            senrev[0]=(buffer[3]<<4)|buffer[2];

            WT_CHIP(0x04);MAX813_WDI=0;

            goto ext_out;

            }

          if(KEY4==0)

           {

            senrev[0]=(buffer[1]<<4)|buffer[0];

            WT_CHIP(0x03);

            BUZER_SUB();MAX813_WDI=0;

            senrev[0]=(buffer[3]<<4)|buffer[2];

            WT_CHIP(0x04);

            while(KEY4==0) MAX813_WDI=0;

            goto ext_out;

            }

          }

        }//时间设置结束

//**********************************************ggggggggggg************************

     if(KEY3==0)//参数设置

       {B_Txs=120;

        BUZER_SUB();

        MAX813_WDI=0;

sagain: Clear_LCD();

        segm=0;

        Clear_LCD();

        RD_CHIP(0x20);

        t1=senrev[0];

        t2=senrev[1];

        buffer[3]=t1/10;

        buffer[2]=t1%10;

        buffer[1]=t2/10;

        buffer[0]=t2%10;

        

        RD_CHIP(0x22);

        t3=senrev[0];

        t4=senrev[1];

        buffer[7]=t3/10;

        buffer[6]=t3%10;

        buffer[5]=t4/10;

        buffer[4]=t4%10;

        

        RD_CHIP(0x24);

        temp[0]=senrev[0];

        temp[1]=senrev[1];

        RD_CHIP(0x26);

        temp[2]=senrev[0];

        temp[3]=senrev[1];

        F_cros_disp=0;

        display4();

        dl_ms(20);

        while(KEY3==0) MAX813_WDI=0;       

        while(1)

         {

          MAX813_WDI=0;

          if(KEY5==0)

           { shift_cnt+=1;BUZER_SUB();

             B_Txs=120;

             dl_ms(20);

             while(KEY5==0) MAX813_WDI=0;

             dl_ms(200);               

            }

           switch(shift_cnt)

             {

              case 0:  

              WRCOM(0x92);

              WRDATA(num_MODE[t2/10]);

              WRDATA(num_MODE[t2%10]);

              WRCOM(0x92);WRCOM(0x0d);

              if(KEY3==0) //时间加

               {t2+=1;

                B_Txs=120;

                if(t2>59)

                 {

                   t2=0;

                 }

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

               if(KEY2==0) //时间加

               {t2-=1;B_Txs=120;

                if(t2>59)

                 {

                   t2=59;

                 }

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

                buffer[1]=t2/10;

                buffer[0]=t2%10;

              break;

              case 1:

              WRCOM(0x90);

              WRDATA(num_MODE[t1/10]);

              WRDATA(num_MODE[t1%10]);

              WRCOM(0x90);WRCOM(0x0d);

              if(KEY3==0) //时间加

               {t1+=1;B_Txs=120;

                if(t1>23)

                 {

                   t1=0;

                 }

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

               if(KEY2==0) //时间加

               {t1-=1;B_Txs=120;

                if(t1>23)

                 {

                   t1=23;

                 }

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

                buffer[3]=t1/10;

                buffer[2]=t1%10;

              break;

              case 2:

              WRCOM(0x96);

              WRDATA(num_MODE[t4/10]);

              WRDATA(num_MODE[t4%10]);

              WRCOM(0x96);WRCOM(0x0d);   

              if(KEY3==0) //时间加

               {t4+=1;B_Txs=120;

                if(t4>59)

                 {

                   t4=0;

                 }

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

               if(KEY2==0) //时间加

               {t4-=1;B_Txs=120;

                if(t4>59)

                 {

                   t4=59;

                 }

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

                buffer[5]=t4/10;

                buffer[4]=t4%10;

              break;

              case 3:

              WRCOM(0x94);

              WRDATA(num_MODE[t3/10]);

              WRDATA(num_MODE[t3%10]);

              WRCOM(0x94);WRCOM(0x0d);

              if(KEY3==0) //时间加

               {t3+=1;B_Txs=120;

                if(t3>23)

                 {

                   t3=0;

                 }

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

               if(KEY2==0) //时间加

               {t3-=1;B_Txs=120;

                if(t3>23)

                 {

                   t3=23;

                 }

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

                buffer[7]=t3/10;

                buffer[6]=t3%10;

              break;

              

               case 4:

               WRCOM(0x8b);

              WRDATA(num_MODE[temp[0]/10]);

              WRDATA(num_MODE[temp[0]%10]);

              WRCOM(0x8b);WRCOM(0x0d);  

               if(KEY3==0) //起始水温加

               {temp[0]+=1;B_Txs=120;

               if(temp[0]>=99) temp[0]=99;

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

                if(KEY2==0) //起始水温减

               {

                if(temp[0]==0) temp[0]=0;

                else temp[0]-=1;

                B_Txs=120;

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

               break;

               case 5:

               WRCOM(0x8d);

               WRDATA(num_MODE[temp[1]/10]);

               WRDATA(num_MODE[temp[1]%10]);

               WRCOM(0x8d);WRCOM(0x0d);  

               if(KEY3==0) //起始水温加

               {temp[1]+=1;B_Txs=120;

                if(temp[1]>=99) temp[1]=99;

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

                if(KEY2==0) //起始水温减

               {

                if(temp[1]==0) temp[1]=0;

                else temp[1]-=1;

                B_Txs=120;

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

               break;

               case 6:

               WRCOM(0x9b);

               WRDATA(num_MODE[temp[2]/10]);

               WRDATA(num_MODE[temp[2]%10]);

               WRCOM(0x9b);WRCOM(0x0d);  

               if(KEY3==0) //起始水温加

               {temp[2]+=1;B_Txs=120;

                if(temp[2]>=99) temp[2]=99;

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

                if(KEY2==0) //起始水温减

               {

                if(temp[2]==0) temp[2]=0;

                else temp[2]-=1;

                B_Txs=120;

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

               break;

               case 7:

               WRCOM(0x9d);

               WRDATA(num_MODE[temp[3]/10]);

               WRDATA(num_MODE[temp[3]%10]);

               WRCOM(0x9d);WRCOM(0x0d);  

               if(KEY3==0) //终止水温加

               {temp[3]+=1;B_Txs=120;

                if(temp[3]>=99) temp[3]=99;

                BUZER_SUB();

                while(KEY3==0) MAX813_WDI=0;       

                }

                if(KEY2==0) //终止水温减

               {

                if(temp[3]==0) temp[3]=0;

                else temp[3]-=1;

                B_Txs=120;

                BUZER_SUB();

                while(KEY2==0) MAX813_WDI=0;       

                }

               break;

               case 8:

                 k1=1;

                 segm+=1;

                 shift_cnt=0;

                 break;

              }//switch

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

          if((segm==1)&&(k1==1))//第一段

               {

               senrev[0]=t1;//写入第一段起始时间时间加

               WT_CHIP(0x20);

               senrev[0]=t2;

               WT_CHIP(0x21);

               senrev[0]=t3;//写入第一段起始时间时间加

               WT_CHIP(0x22);

               senrev[0]=t4;

               WT_CHIP(0x23);

               senrev[0]=temp[0];

               WT_CHIP(0x24);

               senrev[0]=temp[1];

               WT_CHIP(0x25);

               senrev[0]=temp[2];

               WT_CHIP(0x26);

               senrev[0]=temp[3];

               WT_CHIP(0x27);

               MAX813_WDI=0;

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

                 RD_CHIP(0x28);

                 t1=senrev[0];

                 t2=senrev[1];

                 buffer[3]=t1/10;

                 buffer[2]=t1%10;

                 buffer[1]=t2/10;

                 buffer[0]=t2%10;

               

                 RD_CHIP(0x2a);

                 t3=senrev[0];

                 t4=senrev[1];

                 buffer[7]=t3/10;

                 buffer[6]=t3%10;

                 buffer[5]=t4/10;

                 buffer[4]=t4%10;

                                 

                 RD_CHIP(0x2c);

                 temp[0]=senrev[0];

                 temp[1]=senrev[1];

                 RD_CHIP(0x2e);

                 temp[2]=senrev[0];

                 temp[3]=senrev[1];

                 dl_ms(20);

                 display4();

                 WRCOM(0x82);

                 WRDATA(0xa3); WRDATA(0xb2);

                 F_cros_disp=0;

                 k1=0;

               }

            if((segm==2)&&(k1==1))//第二段

               {

               senrev[0]=t1;//写入第二段起始时间时间加

               WT_CHIP(0x28);

               senrev[0]=t2;

               WT_CHIP(0x29);

               senrev[0]=t3;//写入第二段起始时间时间加

               WT_CHIP(0x2a);

               senrev[0]=t4;

               WT_CHIP(0x2b);

               senrev[0]=temp[0];

               WT_CHIP(0x2c);

               senrev[0]=temp[1];

               WT_CHIP(0x2d);

               senrev[0]=temp[2];

               WT_CHIP(0x2e);

               senrev[0]=temp[3];

               WT_CHIP(0x2f);

               MAX813_WDI=0;

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

                 RD_CHIP(0x30);

                 t1=senrev[0];

                 t2=senrev[1];

                 buffer[3]=t1/10;

                 buffer[2]=t1%10;

                 buffer[1]=t2/10;

                 buffer[0]=t2%10;

                 

                 RD_CHIP(0x32);

                 t3=senrev[0];

                 t4=senrev[1];

                 buffer[7]=t3/10;

                 buffer[6]=t3%10;

                 buffer[5]=t4/10;

                 buffer[4]=t4%10;

                                 

                 RD_CHIP(0x34);

                 temp[0]=senrev[0];

                 temp[1]=senrev[1];

                 RD_CHIP(0x36);

                 temp[2]=senrev[0];

                 temp[3]=senrev[1];

                 dl_ms(20);

                 display4();

                 WRCOM(0x82);

                 WRDATA(0xa3); WRDATA(0xb3);

                 k1=0;

               }

               if((segm==3)&&(k1==1))//第三段

               {

               senrev[0]=t1;//写入第二段起始时间时间加

               WT_CHIP(0x30);

               senrev[0]=t2;

               WT_CHIP(0x31);

               senrev[0]=t3;//写入第二段起始时间时间加

               WT_CHIP(0x32);

               senrev[0]=t4;

               WT_CHIP(0x33);

               senrev[0]=temp[0];

               WT_CHIP(0x34);

               senrev[0]=temp[1];

               WT_CHIP(0x35);

               senrev[0]=temp[2];

               WT_CHIP(0x36);

               senrev[0]=temp[3];

               WT_CHIP(0x37);

               MAX813_WDI=0;

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

                 RD_CHIP(0x38);

                 t1=senrev[0];

                 t2=senrev[1];

                 buffer[3]=t1/10;

                 buffer[2]=t1%10;

                 buffer[1]=t2/10;

                 buffer[0]=t2%10;

                 

                 RD_CHIP(0x3a);

                 t3=senrev[0];

                 t4=senrev[1];

                 buffer[7]=t3/10;

                 buffer[6]=t3%10;

                 buffer[5]=t4/10;

                 buffer[4]=t4%10;

                                 

                 RD_CHIP(0x3c);

                 temp[0]=senrev[0];

                 temp[1]=senrev[1];

                 RD_CHIP(0x3e);

                 temp[2]=senrev[0];

                 temp[3]=senrev[1];

                 dl_ms(20);

                 display4();

                 WRCOM(0x82);

                 WRDATA(0xa3); WRDATA(0xb4);

                 k1=0;

               }

               if((segm==4)&&(k1==1))//第四段

               {

               senrev[0]=t1;//写入第四段起始时间时间加

               WT_CHIP(0x38);

               senrev[0]=t2;

               WT_CHIP(0x39);

               senrev[0]=t3;//写入第四段起始时间时间加

               WT_CHIP(0x3a);

               senrev[0]=t4;

               WT_CHIP(0x3b);

               senrev[0]=temp[0];

               WT_CHIP(0x3c);

               senrev[0]=temp[1];

               WT_CHIP(0x3d);

               senrev[0]=temp[2];

               WT_CHIP(0x3e);

               senrev[0]=temp[3];

               WT_CHIP(0x3f);

               MAX813_WDI=0;

               k1=0;

               goto sagain;

               }

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

          if(F_Txs)

           {

             goto ext_out;

            }

          if(KEY4==0)

           {BUZER_SUB();

            while(KEY4==0) MAX813_WDI=0;

            goto ext_out;

            }

          }

        }///参数设置结束

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

     if(F_Txs)

        {

        goto ext_out;

        }

     if(KEY4==0)

        {

        BUZER_SUB();

        while(KEY4==0) MAX813_WDI=0;

        goto ext_out;

        }



  }//while(1)

ext_out:EX1=1;

F_cros_disp=0;

Clear_LCD();

dl_ms(200);       

}



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

//***********************   sub function of  8583 ***hhhhhhhhhh**********

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

//向8583RAM区写温度 地址首址=fstadrm

void WT_TEMP(uchar fstadrm)

{    load_temp();

     slvadr=0xa0;

     subadr=fstadrm;

     bytecnt=0x02;

     senddata();

       }

//****向8583RAM区写特_码 地址首址=50h*****

void WT_8583_TM(void)

{    uchar i;

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

   {    senrev[0]=0XAA;

        slvadr=0xa0;

        subadr=0x70+i;

        bytecnt=0x01;

        senddata();

   }

}

//****向8583RAM区写时间 地址首址=fstadrt****

void WT_CHIP(uchar fstadrt)

{    slvadr=0xa0;

     subadr=fstadrt;

     bytecnt=1;

     senddata();

}

//配置须写入的温度值

void load_temp(void)

{ senrev[0]=(buffer[0]<<4)|buffer[1];

   senrev[1]=buffer[2];

  }

//配置须写入的时间

void load_time(void)

{ senrev[0]=(buffer[5]<<4)|buffer[6];

   senrev[1]=(buffer[3]<<4)|buffer[4];

    }

//读8583RAM区子程序  地址首址=fstadrp

void RD_CHIP(uchar fstadrp)

{    slvadr=0xa0;

     subadr=fstadrp;

     bytecnt=2;

     revdata();

    }

//*******//启动I2总线*************************

void  start()                                

{                                       

        SDA=1;                       

        RAM_i=RAM_i;                       

        SCL=1;                       

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        SDA=0;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        SCL=0;

}

//************* //释放I2总线************************

void  stop()        

{

        SDA=0;

        RAM_i=RAM_i;

        SCL=1;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        SDA=1;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

        RAM_i=RAM_i;

}

//*****write a byte and receive ack to 8583 *****************

void sentbyte(char a)         

{         uchar i;

        com_data=a;

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

        {

          SDA=cos_bit;

          RAM_i=RAM_i;RAM_i=RAM_i;

          RAM_i=RAM_i;

          SCL=1;

         RAM_i=RAM_i;RAM_i=RAM_i;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

          SCL=0;

          com_data=com_data<<1;

         }

          RAM_i=RAM_i;

          RAM_i=RAM_i;

         SDA=1;                //发送结束

          RAM_i=RAM_i;

          RAM_i=RAM_i;

          SCL=1;        //接收ack

          RAM_i=RAM_i;

          RAM_i=RAM_i;

          F0=0; //clr flag of sent error

          if(SDA==0)

          {

          SCL=0;

          }

          else

          {F0=1;

           SCL=0;

            }

             }

//*******//读一个字节******************************

uchar revbyte(void)      

{

  uchar i,j,dat;

  SDA=1;

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

  {

    RAM_i=RAM_i;

    SCL=0;

    RAM_i=RAM_i;

    RAM_i=RAM_i;

    RAM_i=RAM_i;

    RAM_i=RAM_i;

    RAM_i=RAM_i;

   SCL=1;

  j=SDA;

  dat=(dat<<1);

  dat=(j)|(dat);

  }

   SCL=0;

   RAM_i=RAM_i;

   SDA=0;

        if(ack==0)

        {RAM_i=RAM_i;

         RAM_i=RAM_i;

         SCL=1;

          RAM_i=RAM_i;

          RAM_i=RAM_i;

          RAM_i=RAM_i;

          RAM_i=RAM_i;

          RAM_i=RAM_i;

         SCL=0;

         ack=0;}

         else

         { SDA=1;

             RAM_i=RAM_i;

             RAM_i=RAM_i;



         SCL=1;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

         RAM_i=RAM_i;

          

         SCL=0;

         ack=0;}  

         return(dat);

}

//*****************send a data to 8583 *******************

void senddata(void)

{ uchar i;

  uchar y1;

  start();

  y1=slvadr;

  sentbyte(y1);

  if(F0!=1)

   { y1=subadr;

      sentbyte(y1);

      if(F0!=1)

       { for(i=0;i<bytecnt;i++)

          {y1=senrev;

           sentbyte(y1);

             if(F0==1)

             {goto sdrt;}

             }

         stop();

         dl_ms(20);

        }

     }

sdrt: RAM_i=RAM_i;

}

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

void revdata(void)

{uchar i;

uchar a;

start();

  a=slvadr;

  sentbyte(a);

        if(F0!=1)

        {       

  a=subadr;

    sentbyte(a);

  if(F0!=1)

{

start();

a=slvadr|0x01;

   sentbyte(a);

if(F0!=1)

          {

ack=0;

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

       {

         senrev=revbyte();

        }

  ack=1;

  senrev[bytecnt]=revbyte();

  stop();

  stop();

}

}

}

}

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

//*************end pc8583*************************

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

void        BUZER_SUB(void)

{  SPEAK=0;        //蜂鸣器响

         dl_us(0xf00);

         MAX813_WDI=0;

   SPEAK=1;

}

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

void dl_ms(unsigned int count)

{   uchar i;

       while(count--)

          { for(i=0;i<125;i++)

             { ;          

             }

                   MAX813_WDI=0;

          }

}



//T0中断服务子程序

Timer_0() interrupt 1

{

  B_T1s--;

  MAX813_WDI=1;        //看门狗触发端

if  (B_T1s==0)

     {

       B_T1s=1000;

       F_flash=~F_flash;

       B_Txs--;

       if(B_Txs==0)

          {F_Txs=1;

           B_Txs=1;

           }

      }

}



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

void        dl_us(unsigned int count)

{       unsigned int i;

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

        {

         MAX813_WDI=0;  

        }

}

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

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

//温度计子程序1  ds18b20

//*********************jjjjjjj********************************************

uchar  rst(void)         //发复位脉冲

{

uchar presence=1;

dat_1820=0;

dl_us(82);                 //延时公式= 30 + (i-1)*13us

dat_1820=1;

dl_us(4);

presence=dat_1820;

dl_us(28);

return presence;

}

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

bit  rdbit(void)         //读一个位

{ uchar i;

bit dat_bit;

dat_1820=0;i++;

dat_1820=1;i++;i++;

dat_bit=dat_1820;



dat_1820=0;

i=8;                //i=3,4,5,7,8分别延时30,39,47,62,70微妙

while(i>0)

{i--;}

dat_1820=1;i++;i++;

return(dat_bit);

}



uchar rdbyte(void)         //读一个字节

{  uchar i,j,dat;

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

  {

  j=rdbit();

  dat=(j<<7)|(dat>>1);

  }

return(dat);

}



void wtbyte(uchar dat)         //写一个字节

{  unsigned int i;

  uchar j;

  bit testb;

  for(j=1;j<=8;j++)

  {

  testb=dat&0x01;

  dat=dat>>1;

   if(testb)                        //写1

    {

      dat_1820=0;i++;i++;

      dat_1820=1;

      i=7;

      while(i>0)

      {i--;}

     }

    else                        //写0

     {

       dat_1820=0;

       i=7;

       while(i>0)

       {i--;}

       dat_1820=1;

       i++;i++;

      }

   }

}



void  tempst(void)         //开始温度转换sssss

{   

    if(rst())

      {

       buffer[0]=buffer[1]=buffer[2]=0;

       return;

       }

    wtbyte(0xcc);          //跳过rom检测

    wtbyte(0x44);         //开始读温度

    dl_ms(8);   

}



uchar rdtemp(void)         //开始读温度

{

uchar a,b,y1,y2,y3=0;

int ba,BA;

TEMP_SIGN=0;

    if(rst())

      {

       buffer[0]=buffer[1]=buffer[2]=0;

       return 0;

       }

    dl_ms(2);

    wtbyte(0xcc);          //跳过rom检测

    wtbyte(0xbe);               //开始读温度暂存器

    a=rdbyte();            //读温度暂存器低字节

    b=rdbyte();                   //读温度暂存器高字节

/**测试温度时用

    FBA=FBA+16;           //FBA初值=0xfc00;

    a=FBA&0x00ff;

    b=(FBA&0xff00)>>8;                //-25.0625

    _nop_();

*/

//    a=0xd0;

//    b=0x07;   //+125

    if(b>128)

    {        ba=(b*256+a);

            BA=(~ba+1)>>4;

        BA=BA&0x07ff;

        TEMP_SIGN=1;  

        y3=BA;

    }

    else

    {   y1=a>>4;

        y2=b<<4;   

        y3=y1|y2;

        buffer[2]=buffer1[a&0x0f];

    }

    return(y3);   

}

   

void        FIR_mrd1820(void)   //18b20的主读程序

     { uchar idata last;

//     uchar lsb,msb;

        ET0=0;          //读18b20时关T0中断

        TR0=0;

     tempst();                //写18b20

     dl_us(150);        //延时

     last=rdtemp();

     buff_last=last;

     dl_us(50);        //延时

     if(TEMP_SIGN==1)

     { buffer[0]=10;

       buffer[1]=last/10;

       buffer[2]=last%10;

       }

     else

     { buffer[0]=last/10;

       buffer[1]=last%10;

          }      

        ET0=1;         

        TR0=1;

}//*****************************************************************

//温度计子程序2  ds18b20

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

uchar  rst2(void)         //发复位脉冲

{

uchar presence=1;

S2 =0;

dl_us(82);                 //延时公式= 30 + (i-1)*13us

S2 =1;

dl_us(4);

presence=S2 ;

dl_us(28);

return presence;

}

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

bit  rdbit2(void)         //读一个位

{ uchar i;

bit dat_bit;

S2 =0;i++;

S2 =1;i++;i++;

dat_bit=S2 ;



S2 =0;

i=8;                //i=3,4,5,7,8分别延时30,39,47,62,70微妙

while(i>0)

{i--;}

S2 =1;i++;i++;

return(dat_bit);

}

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

uchar rdbyte2(void)         //读一个字节

{  uchar i,j,dat;

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

  {

  j=rdbit2();

  dat=(j<<7)|(dat>>1);

  }

return(dat);

}

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

void wtbyte2(uchar dat)         //写一个字节

{  unsigned int i;

  uchar j;

  bit testb;

  for(j=1;j<=8;j++)

  {

  testb=dat&0x01;

  dat=dat>>1;

   if(testb)                        //写1

    {

      S2 =0;i++;i++;

      S2 =1;

      i=7;

      while(i>0)

      {i--;}

     }

    else                        //写0

     {

       S2 =0;

       i=7;

       while(i>0)

       {i--;}

       S2 =1;

       i++;i++;

      }

   }

}

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

void  tempst2(void)         //开始温度转换sssss

{   

    if(rst2())

      {

       buffer[3]=buffer[4]=buffer[5]=0;

       return;

       }

    wtbyte2(0xcc);          //跳过rom检测

    wtbyte2(0x44);         //开始读温度

    dl_ms(8);   

}

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

uchar rdtemp2(void)         //开始读温度

{

uchar a,b,y1,y2,y3=0;

int ba,BA;

TEMP_SIGN=0;

    if(rst2())

      {

       buffer[3]=buffer[4]=buffer[5]=0;

       return 0;

       }

    dl_ms(2);

    wtbyte2(0xcc);          //跳过rom检测

    wtbyte2(0xbe);               //开始读温度暂存器

    a=rdbyte2();            //读温度暂存器低字节

    b=rdbyte2();                   //读温度暂存器高字节

/**测试温度时用

    FBA=FBA+16;           //FBA初值=0xfc00;

    a=FBA&0x00ff;

    b=(FBA&0xff00)>>8;                //-25.0625

    _nop_();

*/

//    a=0xd0;

//    b=0x07;   //+125

    if(b>128)

    {        ba=(b*256+a);

            BA=(~ba+1)>>4;

        BA=BA&0x07ff;

        TEMP_SIGN=1;  

        y3=BA;

    }

    else

    {   y1=a>>4;

        y2=b<<4;   

        y3=y1|y2;

        buffer[5]=buffer1[a&0x0f];

    }

    return(y3);   

}

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

void        FIR_mrd18202(void)   //18b20的主读程序

     { uchar idata last;

        ET0=0;          //读18b20时关T0中断

        TR0=0;

     tempst2();                //写18b20

     dl_us(150);        //延时

     last=rdtemp2();

     buff_last=last;

     dl_us(50);        //延时

     if(TEMP_SIGN==1)

     { buffer[3]=10;

       buffer[4]=last/10;

       buffer[5]=last%10;

       }

     else

     { buffer[3]=last/10;

       buffer[4]=last%10;

          }      

        ET0=1;         

        TR0=1;

}

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

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

ext0() interrupt 0 //

{        

      EX0=0;

      dl_ms(40);

                if(P32==0)

               { F_hand=0;

                 RL2=RL3=RL4=RL5=0;

                 Clear_LCD();

               

                WRCOM(0x90);WRCOM(0x90);

               

                WRDATA(0xbe);WRDATA(0xaf);

                WRDATA(0xb8);WRDATA(0xe6);

                WRDATA(0xa1);WRDATA(0xc3);

               

                WRDATA(0xcb);WRDATA(0xae);

                WRDATA(0xce);WRDATA(0xc2);

               

                WRDATA(0xb9);WRDATA(0xfd);

                WRDATA(0xb8);WRDATA(0xdf);

               

                WRDATA(0xa3);WRDATA(0xa1);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

                BUZER_SUB();

                dl_ms(100);

               

                Clear_LCD();

                 F_control=0;

                 }

     EX0=1;

}

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

//************液晶显示****************

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

void    Lcd_init(void)

{       

        WRCOM(0x01);

        dl_us(2);



       

        WRCOM(0x02);

        dl_us(2);

       

        WRCOM(0x0c);

        dl_us(2);



}

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

void         Clear_LCD(void)

{        WRCOM(0x01);

        dl_us(2);

}

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

void         LCDBUSY(void)

{        EE        = 0;

        RW        = 1;

        RS        = 0;

        dl_us(100);

        EE        = 1;

        //while  (BF==1);

        EE        = 0;

}

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

void        WRCOM        (char showctl)

{

        LCDBUSY();

        RW        = 0;

        RS        = 0;

        P0        = showctl;

        EE        = 1;

        dl_us(2);

        EE        = 0;

}

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

void        WRDATA(char showctl)

{

        LCDBUSY();

        RW        = 0;

        RS        = 1;

        dl_us(2);

        P0        = showctl;

        EE        = 1;

        dl_us(2);

        EE        = 0;

}



void display1(void)

{

        uchar i=0,j=0;

        

}

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

void display2(void)

{

        uchar i=0,j=0;

        //*************显示水温**********************

        WRCOM(0x80);

        WRCOM(0x0c);

        

        WRDATA(0xcb);

        WRDATA(0xae);

        

        WRDATA(0xce);

        WRDATA(0xc2);

        

        WRDATA(0xa1);

        WRDATA(0xc3);

        

        WRDATA(num_MODE[buffer[0]]);

        WRDATA(num_MODE[buffer[1]]);

        WRDATA(0x2e);

        WRDATA(num_MODE[buffer[2]]);

        //*************显示室内温度**********************

        WRCOM(0x90);

        WRDATA(0xca);

        WRDATA(0xd2);

        

        WRDATA(0xce);

        WRDATA(0xc2);

        

        WRDATA(0xa1);

        WRDATA(0xc3);

        

        WRDATA(num_MODE[buffer[3]]);

        WRDATA(num_MODE[buffer[4]]);

        WRDATA(0x2e);

        WRDATA(num_MODE[buffer[5]]);

        //**************时间****************

        RD_CHIP(0x03);

          i=senrev[1]>>4;

          j=senrev[1]&0x0f;

          WRCOM(0x88);

        WRDATA(0xca);

        WRDATA(0xb1);

        

        WRDATA(0xbc);

        WRDATA(0xe4);

        

        WRDATA(0xa1);

        WRDATA(0xc3);

        

        WRDATA(num_MODE);

        WRDATA(num_MODE[j]);

        if(F_flash)

               {

                WRDATA(0x3a);

                }

              else

              {

               WRDATA(0x20);

              }

          j=i=0;

          i=senrev[0]>>4;

          j=senrev[0]&0x0f;

          WRDATA(num_MODE);

        WRDATA(num_MODE[j]);

          //*************循环水加热**********************

         

        if(F_hand)

          {        WRCOM(0x98);

                  WRDATA(0xb1);WRDATA(0xc3);//泵

                  if(RL1)

                   {WRDATA(0xb9);WRDATA(0xa4);//工作

                    WRDATA(0xd7);WRDATA(0xf7);

                    }

                  else

                    {WRDATA(0xcd);WRDATA(0xa3);//停止

                     WRDATA(0xd6);WRDATA(0xb9);

                    }

                  WRCOM(0x9c);

                  WRDATA(0xbc);WRDATA(0xd3);//加热

                  WRDATA(0xc8);WRDATA(0xc8);

                     if(RL2)

                   { WRDATA(0x18);

                    }

                   else WRDATA(0x20);

         

                   if(RL3)

                   { WRDATA(0x18);

                    }

                    else WRDATA(0x20);

         

                   if(RL4)

                   { WRDATA(0x18);

                    }

                   else WRDATA(0x20);

         

                  if(RL5)

                   { WRDATA(0x18);

                    }

                  else WRDATA(0x20);

          }

         else if((!F_hand)&&(!RL1))

          {     WRCOM(0x98);WRCOM(0x98);

                  WRDATA(0xc7);WRDATA(0xeb);//请按开关键

                  WRDATA(0xb0);WRDATA(0xb4);

                  WRDATA(0xbf);WRDATA(0xaa);

                  WRDATA(0xb9);WRDATA(0xd8);

                  WRDATA(0xbc);WRDATA(0xfc);

          }

         else

         {

           ;      

         }

                                  

}

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

void display3(void)

{       WRCOM(0x90);

        WRDATA(0xca);

        WRDATA(0xb1);

        

        WRDATA(0xbc);

        WRDATA(0xe4);

        WRDATA(0x20);WRDATA(0x20);

        WRDATA(num_MODE[buffer[3]]);

        WRDATA(num_MODE[buffer[2]]);

        WRDATA(0xa1);

        WRDATA(0xc3);

        WRDATA(num_MODE[buffer[1]]);

        WRDATA(num_MODE[buffer[0]]);

}

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

void display4(void)

{       //*********************************************************

        WRCOM(0x80);

        WRDATA(0xca); WRDATA(0xb1);WRDATA(0xb6); WRDATA(0xce);//时段

        WRDATA(0xa3); WRDATA(0xb1);WRDATA(0xa1); WRDATA(0xc3);//1 ：

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

        WRCOM(0x90);

        WRDATA(num_MODE[buffer[3]]);

        WRDATA(num_MODE[buffer[2]]);

        WRDATA(0xa1);

        WRDATA(0xc3);

        WRDATA(num_MODE[buffer[1]]);

        WRDATA(num_MODE[buffer[0]]);

        

        WRDATA(0xa9); WRDATA(0xa9);

        

        WRDATA(num_MODE[buffer[7]]);

        WRDATA(num_MODE[buffer[6]]);

        WRDATA(0xa1);

        WRDATA(0xc3);

        WRDATA(num_MODE[buffer[5]]);

        WRDATA(num_MODE[buffer[4]]);

        //***********水温*******************************************

        WRCOM(0x88);

        WRDATA(0xcb);WRDATA(0xae);WRDATA(0xce);WRDATA(0xc2);

        WRDATA(0xa1);WRDATA(0xc3);

        WRDATA(num_MODE[temp[0]/10]);

        WRDATA(num_MODE[temp[0]%10]);

        WRDATA(0xa9); WRDATA(0xa9);

        WRDATA(num_MODE[temp[1]/10]);

        WRDATA(num_MODE[temp[1]%10]);

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

        //室温

        WRCOM(0x98);

        WRDATA(0xca);WRDATA(0xd2);WRDATA(0xce);WRDATA(0xc2);

        WRDATA(0xa1);WRDATA(0xc3);

        WRDATA(num_MODE[temp[2]/10]);

        WRDATA(num_MODE[temp[2]%10]);

        WRDATA(0xa9); WRDATA(0xa9);

        WRDATA(num_MODE[temp[3]/10]);

        WRDATA(num_MODE[temp[3]%10]);

}

wgxrc

请问楼主,4.7K的电阻不加会出现什么情况?

wentao

请问楼主：18B20读序列号时间是多长。温度转换时间为0.75S，如果读取序列号的时间再长点的话就很慢了

wentao

请教楼主及各位：温度一致是85度是怎么回事？

wolf0801

这么长的程序，没有多大意义 ，打个包不好吗 ？

swordKING

温度一直是85的话,就代表你的温度传感器没启动,

swordKING

33楼



wrdat(0xcc);      //写CCH到DS18B20，以便跳过ROM匹配

wrdat(0x44);       //启动DS18B20进行温度转换

这个中间有点问题,需要一定的延时,现在自己电脑不在身边,等拿到电脑给你发一个

wtx31523180

回去好好看看  努力调

vipeinstein

温度一直是85的话,就代表你的温度转换没有完成你就读了，一般启动转换后等待1S比较稳定，因为很多18b20挂一起的话，转换时间差别很大

guxingganyue

mark

lpf2011

MARK

xinjie1023

收藏。不知能传输多少米？