Design av DS18B20 digital temperatursensor for STM32

DS18B20 er en digital temperatursensor som bruker en enkelt busstiming for å kommunisere med verten. Bare 1 Ledning er nødvendig for å fullføre temperaturdataavlesningen;

DS18B20 har et innebygd 64-bits produktserienummer for enkel identifikasjon. Flere DS18B20-sensorer kan kobles til 1 Metalltråd, og gjennom 64-bits identitetsautentisering, temperaturinformasjonen samlet inn fra forskjellige sensorer kan leses separat.

DS18B20 temperaturfølende tråd i rustfritt stål sondesett

DS18B20 temperaturfølersonde TPE Overstøpesett

1 ledning DS18B20 temperatursensor

Introduksjon til DS18B20
2.1 Hovedtrekkene til DS18B20
1. Helt digital temperaturkonvertering og utgang.
2. Avansert enkeltbuss datakommunikasjon.
3. Opptil 12-biters oppløsning, med en nøyaktighet på opptil ±0,5 grader Celsius.
4. Maksimal arbeidssyklus ved 12-biters oppløsning er 750 millisekunder.
5. Parasittisk arbeidsmodus kan velges.
6. Deteksjonstemperaturområdet er –55°C ~+125°C (–67°F ~+257°F).
7. Innebygd EEPROM, temperaturgrense alarmfunksjon.
8. 64-bit fotolitografi ROM, innebygd produktserienummer, praktisk for tilkobling av flere maskiner.
9. Ulike emballasjeformer, tilpasse seg forskjellige maskinvaresystemer.

DS18B20 brikkepakkestruktur

2.2 DS18B20 pinnefunksjon
GND spenningsjord;
DQ enkel databuss;
VDD strømforsyningsspenning;
NC tom pinne;

DS18B20-brikke RAM og EEPROM strukturdiagram

2.3 DS18B20 arbeidsprinsipp og anvendelse
DS18B20 temperaturdeteksjon og digital datautgang er fullt integrert på én brikke, så den har sterkere anti-interferensevne. Den ene arbeidssyklusen kan deles inn i to deler, nemlig temperaturdeteksjon og databehandling.

18B20 har tre former for minneressurser. Det er de: ROM skrivebeskyttet minne, brukes til å lagre DS18B20ID-kode; den første 8 biter er enkeltlinjes seriekode (DS18B20-koden er 19H), følgende 48 bits er det unike serienummeret til brikken; den siste 8 biter er CRC-koden (redundanssjekk) av ovenstående 56 biter. Dataene settes ved produksjon og kan ikke endres av brukeren. DS18B20 har totalt 64 biter av ROM.

RAM-dataregister, brukes til intern beregning og datatilgang, data går tapt etter strømbrudd, DS18B20 har totalt 9 byte med RAM, hver byte er 8 biter. Den første og andre byten er dataverdiinformasjonen etter temperaturkonvertering; den tredje og fjerde byten er speilbildet av brukerens EEPROM (ofte brukt for lagring av temperaturalarmverdier). Verdien vil bli oppdatert når strømmen tilbakestilles. Den femte byten er speilbildet av brukerens tredje EEPROM. Den 6, 7th, og 8. byte er telleregistre, som er designet for å tillate brukere å oppnå høyere temperaturoppløsning. De er også midlertidige lagringsenheter for intern temperaturkonvertering og beregning. Den niende byten er CRC-koden til den første 8 bytes. EEPROM er et ikke-flyktig minne som brukes til å lagre data som må lagres i lang tid, øvre og nedre temperaturalarmverdier, og verifikasjonsdata. DS18B20 har totalt 3 biter av EEPROM, og det er speilbilder i RAM for å lette brukerbetjeningen.

DS18B20 fungerer i 12-biters oppløsningsmodus som standard. 12-biters data oppnådd etter konvertering lagres i to 8-bits RAM-er på DS18B20 (de to første bytene). Den første 5 biter i binær er tegnbiter. Hvis den målte temperaturen er større enn 0, disse 5 biter er 0. Bare multipliser den målte verdien med 0.0625 for å få den faktiske temperaturen. Hvis temperaturen er lavere enn 0, disse 5 biter er 1. Den målte verdien må inverteres, lagt til av 1, og deretter multiplisert med 0.0625 for å få den faktiske temperaturen. Eller bruk bitoperasjon for å trekke ut temperatur: desimalene opptar den nederste 4 biter, og de øvre bitene er heltallsbiter (negative tall vurderes ikke).

2.4 DS18B20 brikke ROM instruksjonstabell
1. Les ROM [33H] (det heksadesimale kommandoordet er i hakeparenteser).
Denne kommandoen lar busskontrolleren lese 64-bits ROM til DS18B20. Denne instruksen kan kun brukes når det kun er én DS18B20 på bussen. Hvis mer enn én er tilkoblet, datakonflikter vil oppstå under kommunikasjon.

2. atch ROM [55H]
Denne instruksjonen følges av et 64-biters serienummer utstedt av kontrolleren. Når det er flere DS18B20-er på bussen, bare brikken med samme serienummer som den utstedt av kontrolleren kan svare, og de andre brikkene vil vente på neste tilbakestilling. Denne instruksjonen er egnet for enkeltbrikke- og multibrikketilkoblinger.

3. Skip ROM [CCH]
Denne instruksjonen gjør at brikken ikke reagerer på ROM-koden. Når det gjelder en enkelt buss, denne instruksjonen kan brukes for å spare tid. Hvis denne instruksjonen brukes når flere brikker er tilkoblet, datakonflikter vil oppstå, resulterer i feil.

4. Søk i ROM [F0H]
Etter at brikken er initialisert, søkeinstruksjonen lar 64-bit ROM til alle enheter identifiseres ved eliminering når flere brikker er koblet til bussen.

5. Alarmsøk [HVER]
Ved flere sjetonger, søkeinstruksjonen for alarmbrikke reagerer bare på brikker som oppfyller alarmbetingelsen for temperatur høyere enn TH eller mindre enn TL. Så lenge brikken ikke er slått av, alarmtilstanden vil opprettholdes til temperaturen måles igjen og alarmtilstanden ikke er nådd.

6. Skriv Scratchpad [4EH]
Dette er instruksjonen for å skrive data til RAM. De to bytene med data som skrives etterpå vil bli lagret på adressen 2 (TH av alarm RAM) og adresse 3 (TL av alarm RAM). Skriveprosessen kan avsluttes med et tilbakestillingssignal.

7. Les Scratchpad (lese data fra RAM) [BEH]
Denne instruksjonen vil lese data fra RAM, starter fra adresse 0 og opp til adresse 9, fullføre lesingen av hele RAM-dataene. Brikken lar tilbakestillingssignalet avslutte leseprosessen, det er, de påfølgende unødvendige bytene kan ignoreres for å redusere lesetiden.

8. Kopier skrapelodd (kopier RAM-data til EEPROM) [48H]
Denne instruksjonen lagrer dataene i RAM i EEPROM slik at dataene ikke går tapt når strømmen er av. Siden brikken er opptatt med EEPROM-lagringsbehandling, når kontrolleren sender en lesetidsluke, bussutgangene “0”, og når lagringsarbeidet er fullført, bussen vil sende ut “1”.
I parasittisk arbeidsmodus, en sterk pull-up må brukes umiddelbart etter at denne instruksen er utstedt og vedlikeholdes i minst 10MS for å opprettholde brikkedrift.

9. Konverter T (temperaturkonvertering) [44H]
Etter å ha mottatt denne instruksjonen, brikken vil utføre en temperaturkonvertering og lagre den konverterte temperaturverdien i den første og andre adressen til RAM. Siden brikken er opptatt med temperaturkonverteringsbehandling, når kontrolleren sender en lesetidsluke, bussutgangene “0”, og når lagringsarbeidet er fullført, bussen vil sende ut “1”. I parasittisk arbeidsmodus, en sterk pull-up må brukes umiddelbart etter at denne instruksjonen er utstedt og vedlikeholdes i minst 500 MS for å opprettholde brikkedriften.

10. Tilbakekall EEPROM (Kopier alarmverdien i EEPROM til RAM) [B8H]
Denne instruksjonen kopierer alarmverdien i EEPROM til 3. og 4. byte i RAM. Siden brikken er opptatt med kopieringsbehandling, når kontrolleren sender en lesetidsluke, bussutgangene “0”, og når lagringsarbeidet er fullført, bussutgangene “1”. I tillegg, denne instruksjonen vil bli utført automatisk når brikken slås på og tilbakestilles. På denne måten, de to alarmbyte-bitene i RAM vil alltid være speilbildet av dataene i EEPROM.

11. Les Strømforsyning (Bryter for arbeidsmodus) [B4H]
Etter at denne instruksen er gitt, et lesetidsgap utstedes, og brikken vil returnere strømstatusordet. “0” er den parasittiske makttilstanden og “1” er den eksterne krafttilstanden.

2.5 DS18B20 tidsdiagram
2.5.1 DS18B20 Nullstillings- og responsrelasjonsdiagram
En tilbakestilling må utføres før hver kommunikasjon. Tilbakestillingstiden, ventetid, og responstiden bør være strengt programmert i henhold til timingen.
DS18B20 lese- og skrivetidsgap: DS18B20 datalesing og skriving bekreftes av behandlingsbiten for tidsgapet og kommandoordet for å utveksle informasjon.

DS18B20 tilbakestilling og responsforholdsdiagram

2.5.2 Skriv data 0 og data 1 til DS18B20
I de første 15uS av skrivedatatidsgapet, bussen må trekkes lavt av kontrolleren, og da vil det være chip-sampling-tiden for bussdataene. Samplingstiden er 15~60uS. Hvis kontrolleren trekker bussen høyt under prøvetakingstiden, det betyr å skrive “1”, og hvis kontrolleren trekker bussen lavt, det betyr å skrive “0”.
Hver overføringsbit bør ha en startbit på lavt nivå på minst 15uS, og påfølgende data “0” eller “1” skal være ferdig innen 45uS.
Overføringstiden for hele biten bør holdes på 60~120uS, ellers kan ikke normal kommunikasjon garanteres.
Note: DS18B20 leser og skriver data fra den lave biten.

Skriv data 0 og data 1 til DS18B20

2.5.3 Leser data 0 og data 1 fra DS18B20
Samplingstiden for kontrollen under lesetidsgapet bør være mer nøyaktig. Under lesetidsgapet, verten må også generere et lavt nivå på minst 1uS for å indikere starten på lesetiden. Da, i 15uS etter at bussen er sluppet, DS18B20 vil sende den interne databiten. På dette tidspunktet, dersom kontrollen finner at bussen er høy, det betyr lesing “1”, og hvis bussen er lav, det betyr å lese data “0”. Før du leser hver bit, kontrolleren legger til et startsignal.

Les data 0 og data 1 fra DS18B20

Note: Databiten må leses innen 15uS fra starten av lesegapet for å sikre korrekt kommunikasjon.

Under kommunikasjon, 8 biter av “0” eller “1” brukes som en byte, og lesingen eller skrivingen av byten starter fra den lave biten.

2.5.4 Rekkefølge av lesing av temperatur én gang (kun en enkelt DS18B20 på bussen)

1. Send tilbakestillingssignal
2. Registrer responssignal
3. Send 0xCC
4. Send 0x44
5. Send tilbakestillingssignal
6. Registrer responssignal
7. Skriv 0xcc
8. Skriv 0xbe
9. Løkke 8 ganger for å lese den lave byten med temperatur
10. Løkke 8 ganger for å lese den høye byten med temperatur
11. Syntetiser 16-bits temperaturdata og prosess

3. Førerkode

3.1 DS18B20.c
#inkludere “ds18b20.h”
/*
Funksjon: DS18B20 initialisering
Maskinvaretilkobling: PB15
*/
tomrom ds18b20_init(ugyldig)
{
RCC->APB2ENR|=1<<3; //PB
GPIOB->CRH&=0x0FFFFFFF;
GPIOB->CRH|=0x30000000;
GPIOB->ODR|=1<<15; //Pull-up
}

/*
Funksjon: Sjekk om DS18B20-enheten eksisterer
Returverdi: 1 betyr at enheten ikke eksisterer 0 betyr at enheten er normal
*/
u8 DS18B20_CheckDevice(ugyldig) //Inneholder tilbakestillingspuls, deteksjonspuls
{
DS18B20_OUTPUT_MODE();//Initialiser til utgangsmodus
DS18B20_OUT=0; //Generer tilbakestillingspuls
DelayUs(750); //Generer 750us lavt nivå
DS18B20_OUT=1; //Slipp buss
DelayUs(15); //Vent på DS18B20-svar
hvis(DS18B20_CleckAck())//Oppdag eksistenspuls
{
retur 1;
}
retur 0;
}

/*
Funksjon: Oppdag eksistenspulsen til DS18B20-enheten
Returverdi: 1 indikerer feil 0 indikerer normal
*/
u8 DS18B20_CleckAck(ugyldig)
{
u8 cnt=0;
DS18B20_INPUT_MODE();//Initialiser til inndatamodus
mens(DS18B20_IN&&cnt<200) //Vent på DS18B20 respons eksistenspuls
{
DelayUs(1);
cnt++;
}
hvis(cnt>=200)retur 1; //feil

cnt=0;
mens((!DS18B20_IN)&&cnt<240) //vent til DS18B20 slipper bussen
{
DelayUs(1);
cnt++;
}
hvis(cnt>=240)retur 1; //feil
retur 0;
}

/*
Funksjon: Skriv en byte
Lær først å skrive litt.
*/
void ds18b20_writebyte(u8 cmd)
{
u8 i;
DS18B20_OUTPUT_MODE(); //Initialiser til utgangsmodus
til(i=0;jeg<8;i++)
{
DS18B20_OUT=0; //Generer skrivetidsgap (skrive start)
DelayUs(2);
DS18B20_OUT=cmd&0x01; //Send faktisk databit
DelayUs(60); //Vent på ferdigstillelse
DS18B20_OUT=1; //Slipp bussen og forbered deg på neste sending
cmd>>=1; //Fortsett å sende neste databit
}
}

/*
Funksjon: Les en byte
Lær først å lese litt.
*/
u8 DS18B20_ReadByte(ugyldig)
{
u8 i,data=0;
til(i=0;jeg<8;i++)
{
DS18B20_OUTPUT_MODE(); //Initialiser til utgangsmodus
DS18B20_OUT=0; //Generer lesetidsgap (lesestart)
DelayUs(2);
DS18B20_OUT=1; //Slipp buss
DS18B20_INPUT_MODE(); //Initialiser til inndatamodus
DelayUs(8); //Vent på DS18B20-datautgang
data>>=1; //Fyll høy bit med 0, standard er 0
hvis(DS18B20_IN) data|=0x80;
DelayUs(60);
DS18B20_OUT=1; //Slipp buss, vent på å lese neste databit
}
returnere data;
}

/*
Funksjon: Les temperaturdataene til DS18B20 én gang
Returverdi: temperaturdataene avlest
Betraktet situasjon: Det er kun én DS18B20 koblet til bussen
*/
u16 DS18B20_ReadTemp(ugyldig)
{
u16 temp=0;
u8 temp_H,temp_L;
DS18B20_CheckDevice(); //Send tilbakestillingspuls, oppdage puls
Ds18b20_writebyte(0XCC); //Hopp over ROM-sekvensdeteksjon
Ds18b20_writebyte(0x44); //Start en temperaturkonvertering

//Vent til temperaturkonverteringen er fullført
mens(Ds18b20_readbyte()!=0xFF){}

DS18B20_CheckDevice(); //Send tilbakestillingspuls, oppdage puls
Ds18b20_writebyte(0XCC); //Hopp over ROM-sekvensdeteksjon
Ds18b20_writebyte(0Xbe); //Les temperaturen

temp_L=DS18B20_ReadByte(); //Les data for lav temperatur
temp_H=DS18B20_ReadByte(); //Les data for høye temperaturer
temp=temp_L|(temp_H<<8); //Syntetisert temperatur
Retur Temp;
}

3.2 DS18B20.h

#ifndef DS18B20_H
#definer DS18B20_H
#inkludere “stm32f10x.h”
#inkludere “sys.h”
#inkludere “forsinkelse.h”
#inkludere “ds18b20.h”
#inkludere “usart.h”

/*Pakkegrensesnitt*/

//Initialiser DS18B20 til inngangsmodus
#definere DS18B20_INPUT_MODE() {GPIOB->CRH&=0x0FFFFFFF;GPIOB->CRH|=0x80000000;}

//Initialiser DS18B20 til utgangsmodus
#definere DS18B20_OUTPUT_MODE(){GPIOB->CRH&=0x0FFFFFFF;GPIOB->CRH|=0x30000000;}

//DS18B20 IO-portutgang
#definere DS18B20_OUT PBout(15)

//DS18B20 IO-portinngang
#definere DS18B20_IN PBin(15)

//Funksjonserklæring
u8 DS18B20_CleckAck(ugyldig);
u8 DS18B20_CheckDevice(ugyldig);
tomrom ds18b20_init(ugyldig);
u16 DS18B20_ReadTemp(ugyldig);
u8 DS18B20_ReadByte(ugyldig);
void ds18b20_writebyte(u8 cmd);
#endif

poYBAGDYdXCAWkKMAAAAK8RNs4s030.png
3.3 Forsinkelsesfunksjon

/*
Funksjon: Forsinkelse i oss
*/
void DelayUs(int oss)
{
#ifdef _SYSTICK_IRQ_
int i,j;
til(i=0;iVAL=0; //CNT-tellerverdi
SysTick->LOAD=9*us; //9 betyr 1us
SysTick->CTRL|=1<<0; //Start timer
gjøre
{
tmp=SysTick->CTRL; //Les status
}mens((!(tmp&1<<16))&&(tmp&1<<0));
SysTick->VAL=0; //CNT-tellerverdi
SysTick->CTRL&=~(1<<0); //Slå av timeren
#endif
};i++)>

3.4 main.c Ring DS18B20 for å lese temperaturen og skrive den ut til serieporten

#inkludere “stm32f10x.h”

#inkludere “ds18b20.h”

u8 DS18B20_ROM[8]; //Lagre 64-biters ROM-koden til DS18B20

Int Main(ugyldig)
{
u16 temp;
USARTx_Heat(USART1,72,115200);//Initialisering av seriell port 1
Ds18b20_init(); //DS18B20 initialisering

/*1. Les 64-biters ROM-koden til DS18B20*/
//Send tilbakestillingspuls, oppdage eksistenspuls
mens(DS18B20_CheckDevice())
{
printf(“DS18B20-enheten eksisterer ikke!\n”);
Delay Ms(500);
}
//Send kommandoen for å lese 64-biters ROM-koden
Ds18b20_writebyte(0x33);

//Sløyfelest 64-biters ROM-kode
til(i=0;jeg<8;i++)
{
DS18B20_ROM[jeg]= DS18B20_ReadByte();
printf(“DS18B20_ROM[%d]=0x%X\n”,jeg,DS18B20_ROM[jeg]);
}

mens(1)
{
/*2. Betjen samtidig alle DS18B20 på bussen for å begynne å konvertere temperatur*/
DS18B20_CheckDevice(); //Send tilbakestillingspuls, oppdage puls
Ds18b20_writebyte(0XCC); //Hopp over ROM-sekvensdeteksjon
Ds18b20_writebyte(0x44); //Start en temperaturkonvertering (la alle DS18B20 på bussen konvertere temperaturen)
Delay Ms(500); //Vent til alle DS18B20 temperaturkonverteringer på linjen er fullført

/*3. Enkel målrettet avlesning av temperaturen til hver DS18B20*/
DS18B20_CheckDevice(); //Send tilbakestillingspuls, oppdage puls
Ds18b20_writebyte(0x55); //Send kommando for å matche ROM
til(i=0;jeg<8;i++) //Send 64-biters kode
{
Ds18b20_writebyte(DS18B20_ROM[jeg]);
}
Ds18b20_writebyte(0Xbe); //Les temperaturen
temp=DS18B20_ReadByte(); //Les lavordens temperaturdata
temp|=DS18B20_ReadByte()<<8; //Les høyordens temperaturdata
printf(“temp1=%d.%d\n”,temp>>4,temp&0xF);
printf(“temp2=%f\n”,temp*0,0625);

Delay Ms(500);
}
}