Proiectarea senzorului digital de temperatură DS18B20 pentru STM32

DS18B20 este un senzor digital de temperatură care folosește un singur moment de bus pentru a comunica cu gazda. Numai 1 Firul este necesar pentru a completa citirea datelor de temperatură;

DS18B20 are un număr de serie al produsului pe 64 de biți încorporat pentru o identificare ușoară. Mai mulți senzori DS18B20 pot fi conectați la 1 Sârmă, și prin autentificarea identității pe 64 de biți, Informațiile de temperatură colectate de la diferiți senzori pot fi citite separat.

DS18B20 Sârmă de temperatură Senzing Sârmă Kit din oțel inoxidabil

Sondă cu senzor de temperatură DS18B20 Kit de supramulare TPE

1 cablu senzor de temperatură DS18B20

Introducere în DS18B20
2.1 Principalele caracteristici ale DS18B20
1. Conversie și ieșire complet digitale a temperaturii.
2. Comunicare avansată de date cu o singură magistrală.
3. Rezoluție de până la 12 biți, cu o precizie de până la ±0,5 grade Celsius.
4. Ciclul maxim de lucru la rezoluție de 12 biți este 750 milisecunde.
5. Modul de lucru parazit poate fi selectat.
6. Intervalul de temperatură de detectare este -55°C ~+125°C (–67° F ~+257° F).
7. EEPROM încorporată, functie de alarma limita de temperatura.
8. 64-ROM fotolitografie pe biți, numărul de serie al produsului încorporat, convenabil pentru conexiune multi-mașină.
9. Diverse forme de ambalare, se adaptează la diferite sisteme hardware.

Structura pachetului de cip DS18B20

2.2 Funcția pin DS18B20
Masa de tensiune GND;
DQ magistrală de date unică;
Tensiunea de alimentare VDD;
Pin gol NC;

DS18B20 chip RAM și diagrama structurii EEPROM

2.3 Principiul de lucru și aplicarea DS18B20
Detectarea temperaturii DS18B20 și ieșirea datelor digitale sunt complet integrate pe un singur cip, deci are o capacitate anti-interferență mai puternică. Unul său ciclu de lucru poate fi împărțit în două părți, și anume detectarea temperaturii și prelucrarea datelor.

18B20 are trei forme de resurse de memorie. Sunt: Memorie ROM numai pentru citire, folosit pentru a stoca codul DS18B20ID; primul 8 biții sunt cod de serie cu o singură linie (Codul DS18B20 este 19H), următoarele 48 biții sunt numărul de serie unic al cipului; ultimul 8 biții sunt codul CRC (verificare de redundanță) dintre cele de mai sus 56 biți. Datele sunt setate la producție și nu pot fi modificate de către utilizator. DS18B20 are un total de 64 biți de ROM.

Registrul de date RAM, utilizat pentru calculul intern și accesul la date, datele se pierd după pană de curent, DS18B20 are un total de 9 octeți de RAM, fiecare octet este 8 biți. Primul și al doilea octet sunt informațiile despre valoarea datelor după conversia temperaturii; al treilea și al patrulea octet sunt imaginea în oglindă a EEPROM-ului utilizatorului (utilizat în mod obișnuit pentru stocarea valorii alarmei de temperatură). Valoarea acestuia va fi reîmprospătată la resetarea alimentării. Al cincilea octet este imaginea în oglindă a celui de-al treilea EEPROM al utilizatorului. Al 6-lea, 7th, iar octeții 8 sunt registre de numărare, care sunt concepute pentru a permite utilizatorilor să obțină o rezoluție mai mare de temperatură. Sunt, de asemenea, unități de stocare temporară pentru conversia și calculul temperaturii interne. Al 9-lea octet este codul CRC al primului 8 octeți. EEPROM este o memorie nevolatilă folosită pentru a stoca date care trebuie salvate pentru o perioadă lungă de timp, valorile de alarmă de temperatură superioară și inferioară, și datele de verificare. DS18B20 are un total de 3 biți din EEPROM, și există imagini în oglindă în RAM pentru a facilita operarea utilizatorului.

DS18B20 funcționează în modul de rezoluție de 12 biți în mod implicit. Datele pe 12 biți obținute după conversie sunt stocate în două RAM-uri de 8 biți ale DS18B20 (primii doi octeți). Primul 5 biții în binar sunt biți de semn. Dacă temperatura măsurată este mai mare decât 0, aceste 5 biţii sunt 0. Doar înmulțiți valoarea măsurată cu 0.0625 pentru a obține temperatura reală. Dacă temperatura este mai mică decât 0, aceste 5 biţii sunt 1. Valoarea măsurată trebuie inversată, adăugat de 1, și apoi înmulțit cu 0.0625 pentru a obține temperatura reală. Sau utilizați operația cu biți pentru a extrage temperatura: zecimale ocupă cele mai mici 4 biți, iar biții superiori sunt biți întregi (numerele negative nu sunt luate în considerare).

2.4 Tabel de instrucțiuni ROM cip DS18B20
1. Citiți ROM-ul [33H] (cuvântul de comandă hexazecimal este între paranteze drepte).
Această comandă permite controlerului de magistrală să citească ROM-ul pe 64 de biți a DS18B20. Această instrucțiune poate fi utilizată numai atunci când există un singur DS18B20 pe magistrală. Dacă sunt conectate mai multe, conflictele de date vor apărea în timpul comunicării.

2. atch ROM [55H]
Această instrucțiune este urmată de un număr de serie pe 64 de biți emis de controler. Când există mai multe DS18B20 în autobuz, poate răspunde doar cipul cu același număr de serie cu cel emis de controler, iar celelalte cipuri vor aștepta următoarea resetare. Această instrucțiune este potrivită pentru conexiunea cu un singur cip și cu mai multe cipuri.

3. Sari peste ROM [CCH]
Această instrucțiune face ca cipul să nu răspundă la codul ROM. În cazul unui singur autobuz, această instrucțiune poate fi folosită pentru a economisi timp. Dacă această instrucțiune este folosită când sunt conectate mai multe cipuri, vor apărea conflicte de date, rezultând erori.

4. Caută în ROM [F0H]
După ce cipul este inițializat, instrucțiunea de căutare permite identificarea ROM-ului pe 64 de biți a tuturor dispozitivelor prin eliminare atunci când mai multe cipuri sunt conectate la magistrală.

5. Căutare alarmă [FIECARE]
În cazul mai multor jetoane, instrucțiunea de căutare a cipurilor de alarmă răspunde numai la cipurile care îndeplinesc condiția de alarmă de temperatură mai mare de TH sau mai mică de TL. Atâta timp cât cipul nu este oprit, starea de alarmă va fi menținută până când temperatura este măsurată din nou și condiția de alarmă nu este atinsă.

6. Scrie Scratchpad [4EH]
Aceasta este instrucțiunea de a scrie date în RAM. Cei doi octeți de date scrise ulterior vor fi stocați la adresa 2 (TH de RAM de alarmă) si adresa 3 (TL de RAM de alarmă). Procesul de scriere poate fi încheiat printr-un semnal de resetare.

7. Citiți Scratchpad (citește datele din RAM) [BEH]
Această instrucțiune va citi datele din RAM, pornind de la adresa 0 si pana la adresa 9, finalizarea citirii întregii date RAM. Cipul permite semnalului de resetare să încheie procesul de citire, adică, octeții care nu sunt necesari ulterior pot fi ignorați pentru a reduce timpul de citire.

8. Copiați Scratchpad (copiați datele RAM pe EEPROM) [48H]
Această instrucțiune stochează datele în RAM în EEPROM, astfel încât datele să nu se piardă atunci când alimentarea este oprită. Deoarece cipul este ocupat cu procesarea stocării EEPROM, când controlerul trimite un interval de timp de citire, ieșirile magistralei “0”, iar când lucrarea de depozitare este finalizată, va ieși magistrala “1”.
În regim de lucru parazit, o tragere puternică trebuie utilizată imediat după emiterea acestei instrucțiuni și menținută timp de cel puțin 10 MS pentru a menține funcționarea cipului.

9. Convertiți T (conversia temperaturii) [44H]
După primirea acestei instrucțiuni, cipul va efectua o conversie a temperaturii și va stoca valoarea convertită a temperaturii în prima și a doua adresă a RAM. Deoarece cipul este ocupat cu procesarea conversiei temperaturii, când controlerul trimite un interval de timp de citire, ieșirile magistralei “0”, iar când lucrarea de depozitare este finalizată, va ieși magistrala “1”. În regim de lucru parazit, o tragere puternică trebuie utilizată imediat după emiterea acestei instrucțiuni și menținută timp de cel puțin 500 MS pentru a menține funcționarea cipului.

10. Apelați EEPROM (Copiați valoarea alarmei din EEPROM în RAM) [B8H]
Această instrucțiune copiază valoarea alarmei din EEPROM în al 3-lea și al 4-lea octet din RAM. Deoarece cipul este ocupat cu procesarea copierii, când controlerul trimite un interval de timp de citire, ieșirile magistralei “0”, iar când lucrarea de depozitare este finalizată, ieșirile magistralei “1”. în plus, această instrucțiune va fi executată automat când cipul este pornit și resetat. În acest fel, cei doi biți de octeți de alarmă din RAM vor fi întotdeauna imaginea în oglindă a datelor din EEPROM.

11. Citiți sursa de alimentare (Comutator mod de lucru) [B4H]
După emiterea acestei instrucțiuni, se emite un interval de timp de citire, iar cipul își va returna cuvântul de stare a puterii. “0” este starea de putere parazita si “1” este starea de alimentare externă.

2.5 Diagrama de sincronizare DS18B20
2.5.1 DS18B20 Diagrama relației de resetare și răspuns
O resetare trebuie efectuată înainte de fiecare comunicare. Timpul de resetare, timp de așteptare, iar timpul de răspuns ar trebui să fie strict programat în funcție de sincronizare.
DS18B20 interval de timp pentru citire și scriere: Citirea și scrierea datelor DS18B20 este confirmată de bitul de procesare a intervalului de timp și de cuvântul de comandă pentru schimbul de informații.

Diagrama relației de resetare și răspuns DS18B20

2.5.2 Scrieți date 0 și date 1 la DS18B20
În primele 15uS ale intervalului de timp de scriere a datelor, autobuzul trebuie tras jos de către controler, și atunci va fi timpul de eșantionare a cipului pentru datele magistralei. Timpul de eșantionare este de 15 ~ 60uS. Dacă controlerul trage magistrala sus în timpul perioadei de eșantionare, înseamnă scris “1”, iar dacă controlerul trage autobuzul jos, înseamnă scris “0”.
Fiecare bit de transmisie ar trebui să aibă un bit de pornire de nivel scăzut de cel puțin 15uS, și datele ulterioare “0” sau “1” ar trebui finalizat în 45uS.
Timpul de transmisie al întregului bit trebuie menținut la 60~120uS, altfel nu se poate garanta comunicarea normală.
Nota: DS18B20 citește și scrie date din bitul scăzut.

Scrieți date 0 și date 1 la DS18B20

2.5.3 Citirea datelor 0 și date 1 de la DS18B20
Timpul de eșantionare al controlului în timpul intervalului de timp de citire ar trebui să fie mai precis. În timpul intervalului de citire, gazda trebuie, de asemenea, să genereze un nivel scăzut de cel puțin 1uS pentru a indica începutul timpului de citire. Apoi, în 15uS după eliberarea autobuzului, DS18B20 va trimite bitul de date intern. În acest moment, dacă controlul constată că autobuzul este sus, înseamnă a citi “1”, iar dacă autobuzul este jos, înseamnă citirea datelor “0”. Înainte de a citi fiecare bit, controlerul adaugă un semnal de pornire.

Citiți datele 0 și date 1 de la DS18B20

Nota: Bitul de date trebuie citit în termen de 15uS de la începutul intervalului de citire pentru a asigura o comunicare corectă.

În timpul comunicării, 8 bucăți de “0” sau “1” sunt folosite ca un octet, iar citirea sau scrierea octetului începe de la bitul scăzut.

2.5.4 Ordinea citirii temperaturii o dată (doar un singur DS18B20 pe autobuz)

1. Trimiteți semnal de resetare
2. Detectează semnalul de răspuns
3. Trimite 0xCC
4. Trimite 0x44
5. Trimiteți semnal de resetare
6. Detectează semnalul de răspuns
7. Scrieți 0xcc
8. Scrieți 0xbe
9. Buclă 8 ori pentru a citi octetul scăzut de temperatură
10. Buclă 8 ori pentru a citi octetul mare de temperatură
11. Sintetizați datele de temperatură pe 16 biți și procesați

3. Cod șofer

3.1 DS18B20.c
#include “ds18b20.h”
/*
Funcţie: Inițializare DS18B20
Conexiune hardware: PB15
*/
void DS18B20_Init(gol)
{
RCC->APB2ENR|=1<<3; //PB
GPIOB->CRH&=0x0FFFFFFF;
GPIOB->CRH|=0x30000000;
GPIOB->ODR|=1<<15; //Tragere în sus
}

/*
Funcţie: Verificați dacă dispozitivul DS18B20 există
Valoarea returnată: 1 înseamnă că dispozitivul nu există 0 înseamnă că dispozitivul este normal
*/
u8 DS18B20_CheckDevice(gol) //Conține puls de resetare, puls de detectare
{
DS18B20_OUTPUT_MODE();//Inițializați în modul de ieșire
DS18B20_OUT=0; //Generați puls de resetare
DelayUs(750); //Generați 750us nivel scăzut
DS18B20_OUT=1; //Eliberați autobuzul
DelayUs(15); //Așteptați răspunsul DS18B20
dacă(DS18B20_CleckAck())//Detectează pulsul existenței
{
reveni 1;
}
reveni 0;
}

/*
Funcţie: Detectează pulsul de existență al dispozitivului DS18B20
Valoarea returnată: 1 indică o eroare 0 indică normal
*/
u8 DS18B20_CleckAck(gol)
{
u8 cnt=0;
DS18B20_INPUT_MODE();//Inițializați în modul de intrare
în timp ce(DS18B20_IN&&cnt<200) //Așteptați impulsul de existență a răspunsului DS18B20
{
DelayUs(1);
cnt++;
}
dacă(cnt>=200)reveni 1; //eroare

cnt=0;
în timp ce((!DS18B20_IN)&&cnt<240) //așteptați ca DS18B20 să elibereze autobuzul
{
DelayUs(1);
cnt++;
}
dacă(cnt>=240)reveni 1; //eroare
reveni 0;
}

/*
Funcţie: Scrieți un octet
Mai întâi învață să scrii puțin.
*/
void DS18B20_WriteByte(u8 cmd)
{
u8 i;
DS18B20_OUTPUT_MODE(); //Inițializați în modul de ieșire
pentru(i=0;i<8;I ++)
{
DS18B20_OUT=0; //Generați un interval de timp de scriere (începe să scrie)
DelayUs(2);
DS18B20_OUT=cmd&0x01; //Trimiteți bitul de date real
DelayUs(60); //Așteptați finalizarea scrierii
DS18B20_OUT=1; //Eliberați autobuzul și pregătiți-vă pentru următoarea transmisie
cmd>>=1; //Continuați să trimiteți următorul bit de date
}
}

/*
Funcţie: Citiți un octet
Mai întâi învață să citești puțin.
*/
u8 DS18B20_ReadByte(gol)
{
u8 i,date=0;
pentru(i=0;i<8;I ++)
{
DS18B20_OUTPUT_MODE(); //Inițializați în modul de ieșire
DS18B20_OUT=0; //Generați interval de timp de citire (începe citirea)
DelayUs(2);
DS18B20_OUT=1; //Eliberați autobuzul
DS18B20_INPUT_MODE(); //Inițializați în modul de intrare
DelayUs(8); //Așteptați ieșirea datelor DS18B20
date>>=1; //Umpleți biți înalți cu 0, implicit este 0
dacă(DS18B20_IN) date|=0x80;
DelayUs(60);
DS18B20_OUT=1; //Eliberați autobuzul, așteptați să citiți următorul bit de date
}
returnează datele;
}

/*
Funcţie: Citiți datele de temperatură ale DS18B20 o dată
Valoarea returnată: datele de temperatură citite
Situație considerată: Există un singur DS18B20 conectat la magistrală
*/
u16 DS18B20_ReadTemp(gol)
{
u16 temp=0;
u8 temp_H,temp_L;
DS18B20_CheckDevice(); //Trimite impuls de resetare, detectează pulsul
DS18B20_WriteByte(0XCC); //Omiteți detectarea secvenței ROM
DS18B20_WriteByte(0x44); //Începeți o conversie a temperaturii

//Așteptați finalizarea conversiei temperaturii
în timp ce(DS18B20_ReadByte()!=0xFF){}

DS18B20_CheckDevice(); //Trimite impuls de resetare, detectează pulsul
DS18B20_WriteByte(0XCC); //Omiteți detectarea secvenței ROM
DS18B20_WriteByte(0Xbe); //Citiți temperatura

temp_L=DS18B20_ReadByte(); //Citiți datele de temperatură scăzută
temp_H=DS18B20_ReadByte(); //Citiți datele de temperatură ridicată
temp=temp_L|(temp_H<<8); //Temperatura sintetizată
temp. retur;
}

3.2 DS18B20.h

#ifndef DS18B20_H
#definiți DS18B20_H
#include “stm32f10x.h”
#include “sys.h”
#include “întârziere.h”
#include “ds18b20.h”
#include “usart.h”

/*Interfață pachet*/

//Inițializați DS18B20 în modul de intrare
#definiți DS18B20_INPUT_MODE() {GPIOB->CRH&=0x0FFFFFFF;GPIOB->CRH|=0x80000000;}

//Inițializați DS18B20 în modul de ieșire
#definiți DS18B20_OUTPUT_MODE(){GPIOB->CRH&=0x0FFFFFFF;GPIOB->CRH|=0x30000000;}

//DS18B20 Ieșire port IO
#definiți DS18B20_OUT PBout(15)

//DS18B20 intrare port IO
#definiți DS18B20_IN PBin(15)

//Declarație de funcție
u8 DS18B20_CleckAck(gol);
u8 DS18B20_CheckDevice(gol);
void DS18B20_Init(gol);
u16 DS18B20_ReadTemp(gol);
u8 DS18B20_ReadByte(gol);
void DS18B20_WriteByte(u8 cmd);
#endif

poYBAGDYdXCAWkKMAAAAK8RNs4s030.png
3.3 Funcția de întârziere

/*
Funcţie: Întârziere în noi
*/
void DelayUs(int noi)
{
#ifdef _SYSTICK_IRQ_
int i,j;
pentru(i=0;iVAL=0; //Valoarea contorului CNT
SysTick->LOAD=9*us; //9 înseamnă 1 noi
SysTick->CTRL|=1<<0; //Porniți cronometrul
do
{
tmp=SysTick->CTRL; //Citiți starea
}în timp ce((!(tmp&1<<16))&&(tmp&1<<0));
SysTick->VAL=0; //Valoarea contorului CNT
SysTick->CTRL&=~(1<<0); //Opriți cronometrul
#endif
};I ++)>

3.4 main.c Apelați DS18B20 pentru a citi temperatura și a o tipări pe portul serial

#include “stm32f10x.h”

#include “ds18b20.h”

u8 DS18B20_ROM[8]; //Stocați codul ROM pe 64 de biți al DS18B20

int Main(gol)
{
u16 temp;
USARTx_Heat(USART1,72,115200);//Inițializarea portului serial 1
DS18B20_Căldură(); //Inițializare DS18B20

/*1. Citiți codul ROM pe 64 de biți al DS18B20*/
//Trimite impuls de resetare, detectează pulsul existenței
în timp ce(DS18B20_CheckDevice())
{
printf(“Dispozitivul DS18B20 nu există!\n”);
ÎntârziereDna(500);
}
//Trimiteți comanda pentru a citi codul ROM pe 64 de biți
DS18B20_WriteByte(0x33);

//Cod ROM de citire în buclă pe 64 de biți
pentru(i=0;i<8;I ++)
{
DS18B20_ROM[i]= DS18B20_ReadByte();
printf(“DS18B20_ROM[%d]=0x%X\n”,i,DS18B20_ROM[i]);
}

în timp ce(1)
{
/*2. Operați simultan toate DS18B20 pe autobuz pentru a începe conversia temperaturii*/
DS18B20_CheckDevice(); //Trimite impuls de resetare, detectează pulsul
DS18B20_WriteByte(0XCC); //Omiteți detectarea secvenței ROM
DS18B20_WriteByte(0x44); //Începeți o conversie a temperaturii (lăsați toate DS18B20 de pe autobuz să convertească temperatura)
ÎntârziereDna(500); //Așteptați ca toate conversiile temperaturii DS18B20 de pe linie să fie finalizate

/*3. Citire unică țintită a temperaturii fiecărui DS18B20*/
DS18B20_CheckDevice(); //Trimite impuls de resetare, detectează pulsul
DS18B20_WriteByte(0x55); //Trimiteți comanda pentru a se potrivi cu ROM-ul
pentru(i=0;i<8;I ++) //Trimite cod pe 64 de biți
{
DS18B20_WriteByte(DS18B20_ROM[i]);
}
DS18B20_WriteByte(0Xbe); //Citiți temperatura
temp=DS18B20_ReadByte(); //Citiți datele de temperatură de ordin scăzut
temp|=DS18B20_ReadByte()<<8; //Citiți date de temperatură de ordin înalt
printf(“temp1=%d.%d\n”,temp>>4,temp&0xF);
printf(“temp2=%f\n”,temp*0,0625);

ÎntârziereDna(500);
}
}