ATNEL tech-forum

Re: Bibioteka dla czujnika wilgotności DHT11/22

2018-03-21T18:46:11+01:00

Dzięki Adriang200 i danielos! Pięknie śmigają biblioteki. A jak przyjemnie się analizuje kod z taką ilością komentarzy. To mi przypomina działalność mirekk36 z czasów jak był młody

Statystyki: Napisane przez jacekrv1 — 21 mar 2018, o 18:46

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-06-04T00:54:37+01:00

Tomek86 napisał(a):

Sam jestem ciekaw który będzie wskazywał dokładnej

DHT22 jest bardziej dokładny co wynika z noty katalogowej. Wystarzy porównać notę dla DHT11 i DHT22

Pozdrawiam

Statystyki: Napisane przez majster — 4 cze 2017, o 00:54

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-06-03T12:08:16+01:00

Adriang200 napisał(a):

Jak byś miał kiedy DHT22 to napisz czy też są takie odchylenia względem stacji meteo.

Ok, dam znać. Posiadam w tej chwili tylko DTH11, pewnie przy kolejnym zamówieniu dołożę do zakupów DTH22.
Sam jestem ciekaw który będzie wskazywał dokładnej

Pozdrawiam,
Tomek.

Statystyki: Napisane przez Tomek86 — 3 cze 2017, o 12:08

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-06-03T11:54:27+01:00

Pomiędzy DHT22 a DHT11 też zaobserwowałem podobną różnicę.
Zawsze można to skalibrować poprzez odjęcie lub dodanie tych 20 punktów by wartości były podobne.
Jak byś miał kiedy DHT22 to napisz czy też są takie odchylenia względem stacji meteo.

Statystyki: Napisane przez Adriang200 — 3 cze 2017, o 11:54

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-06-02T21:22:45+01:00

dzięki @Adriang200

zmodyfikowana biblioteka działa bardzo fajnie

Tak poza tematem, zastanawiam się, czemu pomiar wilgotności przez czujnik DTH11 wskazuje o 20punktów mniej niż stacjonarna stacja meteo (któryś z czujników źle wskazuje )

Statystyki: Napisane przez Tomek86 — 2 cze 2017, o 21:22

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-06-01T19:28:58+01:00

Biblioteka automatycznie wykrywająca typ czujnika, powstała na podstawie kodów udostępnionych przez danielos
Pozdrawiam.

cz_dht.h
[syntax=c]/* cz_dht.h */
/* Wybór PINu oraz PORTu na magistralę 1 przewodową dla DHT11/22*/
#define DHT_PIN PB0
#define DHT_IN PINB
#define DHT_OUT PORTB
#define DHT_DDR DDRB

/*
* BIBLIOTEKA AUTOMATYCZNIE WYKRYJE PODPIĘTY TYP CZUJNIKA
* Obsługa czujnika DHT11 / RHT01 typ_dht = 0
* Obsługa czujnika DHT22 / RHT03 / AM2302 typ_dht = 1
*
*/
extern volatile uint8_t typ_dht;

extern volatile uint8_t flaga_1s;

void init_dht (void);

uint8_t odczyt_dht(uint16_t* humidity, uint16_t* temperature, uint8_t* znak);//odczyt danych[/code][/syntax]

cz_dht.c
[syntax=c]/* cz_dht.c */

#include
#include
#include

#include "cz_dht.h"

#define DHT_GET_IN ( DHT_IN & (1 << DHT_PIN))
#define DHT_OUT_LOW ( DHT_OUT &= (~(1 << DHT_PIN)) )
#define DHT_OUT_HIGH ( DHT_OUT |= (1 << DHT_PIN) )
#define DHT_DIR_IN ( DHT_DDR &= (~(1 << DHT_PIN )) )
#define DHT_DIR_OUT ( DHT_DDR |= (1 << DHT_PIN) )

#define AVERAGE 1
#define NEW 0

#define TIMSK_CTC_ON TIMSK |= (1<#define TIMSK_CTC_OFF TIMSK &= ~(1<

volatile uint8_t flaga_1s;

volatile uint8_t dht_timer;
volatile uint8_t dht_ms;

volatile uint8_t typ_dht = 0;

typedef struct {
uint8_t hum_int;
uint8_t hum_dec;
uint8_t temp_int;
uint8_t temp_frac;
uint8_t checksum;
}t_dht;

typedef union {
uint8_t indeks[5];
t_dht data;
}U_DHT;

U_DHT read_dht;

#if defined (__AVR_ATmega48A__) || (__AVR_ATmega48PA__) || (__AVR_ATmega88A__) || (__AVR_ATmega88PA__) \
|| (__AVR_ATmega168A__) || (__AVR_ATmega168PA__) || (__AVR_ATmega328P__) || (__AVR_ATmega328__)

#define TRYB_CTC TCCR2A |= (1<#define COMPARE_MATCH_ON TIMSK2 |= (1<

#if F_CPU==11059200
#define PRE_SCALER TCCR2B |= (1<#define OCR_USTAW OCR2A = 220 // podział przez 220 dla uzyskania 20us
#elif F_CPU==16000000
#define PRE_SCALER TCCR2B |= (1<#define OCR_USTAW OCR2A = 4 // podział przez 4 dla uzyskania 20us
#elif F_CPU==20000000
#define PRE_SCALER TCCR2B |= (1<#define OCR_USTAW OCR2A = 49 // podział przez 49 dla uzyskania 20us
#endif

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

#elif defined (__AVR_ATmega32__)

#define TRYB_CTC TCCR2 |= (1<#define COMPARE_MATCH_ON TIMSK |= (1<

#if F_CPU==11059200
#define PRE_SCALER TCCR2 |= (1<#define OCR_USTAW OCR2 = 220 // podział przez 220 dla uzyskania 20us
#elif F_CPU==16000000
#define PRE_SCALER TCCR2 |= (1<#define OCR_USTAW OCR2 = 4 // podział przez 4 dla uzyskania 20us
#elif F_CPU==20000000
#define PRE_SCALER TCCR2 |= (1<#define OCR_USTAW OCR2 = 49 // podział przez 49 dla uzyskania 20us
#endif

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

#elif defined (__AVR_ATmega8__)

#define TRYB_CTC TCCR2 |= (1<#define COMPARE_MATCH_ON TIMSK |= (1<

#if F_CPU==11059200
#define PRE_SCALER TCCR2 |= (1<#define OCR_USTAW OCR2 = 220 // podział przez 220 dla uzyskania 20us
#elif F_CPU==16000000
#define PRE_SCALER TCCR2 |= (1<#define OCR_USTAW OCR2 = 4 // podział przez 4 dla uzyskania 20us
#elif F_CPU==20000000
#define PRE_SCALER TCCR2 |= (1<#define OCR_USTAW OCR2 = 49 // podział przez 49 dla uzyskania 20us
#endif

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

#endif

void init_dht( void ) {

TRYB_CTC; //tryb CTC
PRE_SCALER; //preskaler
OCR_USTAW; // podział dla uzyskania 20us
COMPARE_MATCH_ON; // zezwolenie na przerwanie Compare Match

}

uint8_t odczyt_dht( uint16_t* humidity, uint16_t* temperature, uint8_t* znak ) {

uint8_t j = 0, i = 0;

//procedura startu
DHT_DIR_OUT;
DHT_OUT_HIGH;
DHT_OUT_LOW;

//odczekanie więcej jak 18ms dla DHT11
dht_ms = 35;

if ( !typ_dht ) { // DHT11
while ( dht_ms );
} else { // DHT22
//dla dht22 ma być 500us czyli 0,5ms
_delay_us( 500 );
}

DHT_OUT_HIGH;

//ustawienie wejścia
DHT_DIR_IN;

//czekanie na potwierdzenie z czujnika około 10us
dht_timer = 0;
while ( DHT_GET_IN ) {
if ( dht_timer > 10 ) //jeżeli w przeciągu 200us nie nastąpi wyjście
return 0; //zgłoś błąd
}

//Potwierdzenie nadawania przez dht - stan niski i wysoki przez 80us
dht_timer = 0;
while ( !DHT_GET_IN ) { //80us stan niski
if ( dht_timer > 10 ) //jeżeli w przeciągu 200us nie nastąpi wyjście
return 0; //zgłoś błąd
}

while ( DHT_GET_IN ) { //80us stam wysoki
if ( dht_timer > 20 ) //jeżeli w przeciągu 400us nie nastąpi wyjście (kolejne 200us)
return 0; //zgłoś błąd
}

//odczyt danych
//odbiór 5 pakietów danych
for ( j = 0 ; j < 5 ; j++ ) {

//wyzerowanie zmiennej
read_dht.indeks[j] = 0x00;

for ( i = 8 ; i > 0 ; ) {
--i; //najpierw dekrementacja zmiennej

dht_timer = 0; //wyzeruje licznik

while ( !DHT_GET_IN ) { //najpierw stan niski
if ( dht_timer > 10 ) //jeżeli w przeciągu 200us nie nastąpi wyjście
return 0; //zgłoś błąd
}
while ( DHT_GET_IN ) { //następnie stan wysoki
if ( dht_timer > 20 ) //jeżeli w przeciągu 400us nie nastąpi wyjście (kolejne 200us)
return 0; //zgłoś błąd
}

//0 logiczne występuje gdy stan niski trwa 50us a stan wysoki 26-28us
//czyli razem około 80us.
//1 logiczna występuje gdy stan niski trwa 50us a stan wysoki 70us
//czyli razem około 120us
if (( dht_timer >= 6 ) && ( dht_timer <= 8 ) ) {
//jeżeli czas pomiaru stanu wysokiego i niskiego wyniósł
// od 100us do 160 us to wpisz logiczną jedynkę
read_dht.indeks[j] |= ( 1 << i );
}
}
}

dht_timer = 0;
//Zakończenie transmisji sygnalizowane jest stanem niskim trwającym 50us,
//ustawionym przez układ DHT
while ( !DHT_GET_IN ) { //najpierw stan niski
if ( dht_timer > 10 ) //jeżeli w przeciągu 200us nie nastąpi wyjście
return 0; //zgłoś błąd
}

//Ustawienie pinu jako wyjście i ustawienie na nim stanu wysokiego
DHT_DIR_OUT;
DHT_OUT_HIGH;

//obliczenie sumy kontrolnej
uint8_t checksum = (( read_dht.indeks[0] + read_dht.indeks[1] + read_dht.indeks[2] + read_dht.indeks[3] ) );

/***************** DHT11 ************************/
if ( !typ_dht ) {
//czy dane zostałe poprawnie odebrane
if ( checksum == read_dht.indeks[4] ) {

//przepisanie do danych wejściowych
*humidity = read_dht.data.hum_int;
*temperature = read_dht.data.temp_int;
*znak = 0;

return 1;

} else

return 0;

}//typdht
/***************** DHT11 ************************/

/***************** DHT22 ************************/
if ( typ_dht ) {
//czy dane zostałe poprawnie odebrane
if ( checksum == read_dht.indeks[4] ) {

//wilgotność
// uint16_t wilg = (read_dht.indeks[0] << 8) | read_dht.indeks[1];
*humidity = ( read_dht.indeks[0] << 8 ) | read_dht.indeks[1];

//temperatura
int16_t temp = ( read_dht.indeks[2] << 8 ) | read_dht.indeks[3]; // temperatura ze znakiem

//wyłuskanie znaku z wartości ujemnej
if ( temp & 0x8000 ) {
*temperature = temp & 0x7FFF;
*znak = 1; // wartość ujemna
} else {
*temperature = temp;
*znak = 0; // wartość dodatnia
}

return 1;
} else
return 0;
}//typdht
/***************** DHT22 ************************/

return 0;
}

#if defined (__AVR_ATmega8__)
ISR( TIMER2_COMP_vect )
#elif (__AVR_ATmega48A__) || (__AVR_ATmega48PA__) || (__AVR_ATmega88A__) || (__AVR_ATmega88PA__) \
|| (__AVR_ATmega168A__) || (__AVR_ATmega168PA__) || (__AVR_ATmega328P__) || (__AVR_ATmega328__)
ISR( TIMER2_COMPA_vect )
#elif defined (__AVR_ATmega32__)
ISR( TIMER2_COMP_vect )
#endif
{
uint8_t us;

static uint16_t ss = 0;
static uint8_t ms = 0;

if ( ss++ > 49999 ) {

flaga_1s = 1;

ss = 0;
}

if ( ms++ > 49 ) {

us = dht_ms;
if ( us ) dht_ms = --us;
// dht_ms--;

ms = 0;
}

dht_timer++;
}[/syntax]

main.c
[syntax=c]/* main.c */

#include
#include
#include
#include
#include

#include "MK_USART/mkuart.h"

#include "cz_dht.h"

uint16_t wilg, temp;
uint8_t znak;

uint8_t ch;

int main( void ) {
USART_Init( __UBRR );

init_dht();

sei();
ch = odczyt_dht( &wilg, &temp, &znak );
uart_puts( "START\r\n" );

while ( 1 ) {

if ( flaga_1s ) {
static uint8_t stan = 1; // co dwie sekundy jest odczytywana temperatura

if ( !stan ) {
ch = odczyt_dht( &wilg, &temp, &znak );

} else {
if ( ch == 1 ) { // sprawdzenie sumy kontrolnej

// odebranie wartości z czujnika jest sygnalizowane mruganiem diody LED
PORTB ^= ( 1 << PB5 );
DDRB ^= ( 1 << PB5 );

if ( stan ) {
uart_puts( "\f" );
uart_putint( wilg, 10 );
uart_puts( " wilg " );
uart_puts( "\r\n" );

if ( typ_dht ) {
uart_putint( znak, 10 );
uart_puts( " on/off znak minus " );
uart_puts( "\r\n" );
}

uart_putint( temp, 10 );
uart_puts( " temp " );
uart_puts( "\r\n**********\r\n" );

if ( !typ_dht ) uart_puts( " typ czujnika DHT_11" );
else uart_puts( " typ czujnika DHT_22" );
}

} else {
typ_dht ^= 1; // przełączenie na inny typ czujnika
uart_puts( " \f ERROR - brak czujnika \r\n " );
// _delay_ms(500);
}

}

stan ^= 1;
flaga_1s = 0;
}

}
}[/syntax]

Jeszcze potrzebna będzie biblioteka USART, ale to już w własnym zakresie.

Statystyki: Napisane przez Adriang200 — 1 cze 2017, o 19:28

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-05-30T17:03:30+01:00

Adriang200 napisał(a):

Jeszcze troszeczkę dopieściłem i mam automatyczne wykrywanie podłączonego czujnika. Jak ktoś chce to podeślę kod po lekkich modyfikacjach.

Bardzo chętnie przetestuję biblioteczkę , jestem ciekawy jak wykonałeś wykrycie czujnika

Statystyki: Napisane przez Tomek86 — 30 maja 2017, o 17:03

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-05-30T17:39:30+01:00

hmm a ja mam jakieś "zaćmienie umysłu", mi ta biblioteka nie działa... właściwie to utyka na odczycie temperatury.
Myślałem, że może czujnik mam uszkodzony ale na arduino DHT11 działa poprawnie.

Dane platformy testowej:

Zestaw ATB-1.04b (Atmega32)
Czujnik DHT11

Port pod czujnik PB0
[syntax=c]...
/* Wybór PINu oraz PORTu na magistralę 1 przewodową dla DHT11/22*/
#define DHT_PIN PB0
#define DHT_IN PINB
#define DHT_OUT PORTB
#define DHT_DDR DDRB

/*
* Obsługa czujnika DHT11 / RHT01 wybierz 1
* Obsługa czujnika DHT22 / RHT03 / AM2302 wybierz 2
*
*/
#define DHT1
...[/syntax]

i jeszcze plik main.c

[syntax=c]/*
* main.c
*
* Created on: 29.05.2017
* Author: Tomek
*/

/*
* main.c
*
* Created on: 29.05.2017
* Autor: Tomek
*
*/
#include
#include
#include
#include "LCD/lcd44780.h"
#include "DS_DHT/ds_dht.h"

//makra
#define PORT(X) XPORT(X)
#define XPORT(X) PORT##X

#define DDR(X) XDDR(X)
#define XDDR(X) DDR##X

#define PIN(X) XPIN(X)
#define XPIN(X) PIN##X

#define LED_PORT B
#define LED_DEBUG (1<
#define LED_DEBUG_OFF PORT(LED_PORT) |= LED_DEBUG
#define LED_DEBUG_ON PORT(LED_PORT) &= ~LED_DEBUG
#define LED_DEBUG_TOGGLE PORT(LED_PORT) ^= LED_DEBUG

int main( void ) {

DDRB |= LED_DEBUG;
LED_DEBUG_OFF;

sei();// globalne odblokowanie przerwań
//cli();// globalne wyłączenie przerwań

uint16_t pomiar[2];

lcd_init();
ds_init_dht();

lcd_locate(0, 0);
lcd_str("Start...");
_delay_ms(2000);
lcd_cls();

while( 1 ) {// główna pętla programu

LED_DEBUG_TOGGLE;
_delay_ms(2000);
LED_DEBUG_TOGGLE;

ds_read_dht(&pomiar[0], &pomiar[1]);
lcd_locate(0, 0);
lcd_int(pomiar[0]);
lcd_locate(1, 0);
lcd_int(pomiar[1]);

//LED_DEBUG_TOGGLE;

}

}[/syntax]

ehh... wstyd się przyznać, gdybym wcześniej przeczytał...:

[syntax=c]/*
* ds_dht.c
*
* Created on: 19 paź 2016
*Edited on:28 paź 2016
* Author: Daniel
*
*
* Obsługa czujników DHT11 / RHT01 / DHT22 / RHT03 / AM2302
*
* Obsługa AVR Atmega8, Atmega32
* Obsługa częstotliwości 10MHz, 11.0592MHz, 14.7456MHz, 16MHz
*
* Biblioteka wykorzystuje przerwanie od timera 0 w trybie CTC co 20us -
* przerwanie skonfigurowane wewnątrz biblioteki.
* Dodatkowo, wykorzystywane jest przerwanie co 10ms, które należy skonfigurowac
* samodzielnie i w obsłudze przerwania umieścić następujący warunek:
*
* if(dht_ms)
*dht_ms--;
*
*
*
*/[/syntax]

plik: mina.c

[syntax=c]/*
* main.c
*
* Created on: 29.05.2017
* Autor: Tomek
*
*/
#include
#include
#include
#include "LCD/lcd44780.h"
#include "DS_DHT/ds_dht.h"

//makra
#define PORT(X) XPORT(X)
#define XPORT(X) PORT##X

#define DDR(X) XDDR(X)
#define XDDR(X) DDR##X

#define PIN(X) XPIN(X)
#define XPIN(X) PIN##X

#define LED_PORT B
#define LED_DEBUG (1<
#define LED_DEBUG_OFF PORT(LED_PORT) |= LED_DEBUG
#define LED_DEBUG_ON PORT(LED_PORT) &= ~LED_DEBUG
#define LED_DEBUG_TOGGLE PORT(LED_PORT) ^= LED_DEBUG

int main( void ) {

DDRB |= LED_DEBUG;
LED_DEBUG_OFF;

//cli();// globalne wyłączenie przerwań

TCCR2 |= (1 << WGM21);
TCCR2 |= ((1 << CS22) | (1 << CS20));
TIMSK |= (1 << OCIE2);
OCR2 = 107;

sei();// globalne odblokowanie przerwań

uint16_t pomiar[2];

lcd_init();
ds_init_dht();

lcd_locate(0, 0);
lcd_str("Start...");
_delay_ms(2000);
lcd_cls();

while( 1 ) {// główna pętla programu

LED_DEBUG_TOGGLE;
_delay_ms(2000);

ds_read_dht(&pomiar[0], &pomiar[1]);
lcd_locate(0, 0);
lcd_int(pomiar[0]);
lcd_locate(1, 0);
lcd_int(pomiar[1]);
}

}

ISR(TIMER2_COMP_vect)
{
if(dht_ms)
dht_ms--;
}[/syntax]

A więc tak "coś tam się wykonuje", ale dodatkowo musiałem wyrzucić z biblioteki: z pliku ds_dth.c z lini 271: PORTA ^= (1<Bo w innym wypadku miałem znaki zapytania.
Tylko, że na lcd wyświetlają mi się dwie zmienne pomiar[0] o wartości 8709i pomiar[1] 8453, i te wartości się nie zmieniają nawet jak czujnik trzymam w palcach.

Pozdrawiam,
Tomek

Statystyki: Napisane przez Tomek86 — 29 maja 2017, o 19:45

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-05-28T21:15:16+01:00

Super.
Wielkie dzięki za bibliotekę. Przetestowałem na DHT11 - działa, a na DHT22 po małych modyfikacjach kodu pięknie odczytuje wraz ze znakiem temperatury ujemnej.
Jeszcze troszeczkę dopieściłem i mam automatyczne wykrywanie podłączonego czujnika. Jak ktoś chce to podeślę kod po lekkich modyfikacjach.
Pozdrawiam wszystkich.

Statystyki: Napisane przez Adriang200 — 28 maja 2017, o 21:15

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-05-02T18:13:57+01:00

gordon10 napisał(a):

Bardzo fajna biblioteka i działa bez problemu na ATmega644PA (po minimalnych przeróbkach).

Ciesze się, że przydała się kolejnej osobie.

gordon10 napisał(a):

przerwaniach COMPx i PCINTx

hmmm, na pewno ciekawy i niespotykany sposób.
Czekam na wyniki twoich wysiłków - życzę więc powodzenia i wytrwałości.

Statystyki: Napisane przez danielos — 2 maja 2017, o 18:13

Re: Bibioteka dla czujnika wilgotności DHT11/22

2017-04-30T21:22:06+01:00

Bardzo fajna biblioteka i działa bez problemu na ATmega644PA (po minimalnych przeróbkach).
Ja próbowałem obsłużyć ten czujnik na przerwaniach COMPx i PCINTx, ale jakoś opornie mi to idzie...

Statystyki: Napisane przez gordon10 — 30 kwi 2017, o 21:22

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T20:07:26+01:00

10% kalafonii ?
może dać nieprzewidziany efekt,
do resetu lepiej nie mieszać
Uwaga- restart może być uciążliwy.

Statystyki: Napisane przez Daro69 — 29 paź 2016, o 20:07

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T19:35:06+01:00

danielos napisał(a):

Trzeba się w końcu zresetować

Najlepszy reset elektronika:
10% kalafonii
90% spirytusu
Zmieszane w pojemniku 50ml

Wysłane z mojego LIVE przy użyciu Tapatalka

Statystyki: Napisane przez majster — 29 paź 2016, o 19:35

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T19:06:00+01:00

buz11 napisał(a):

No i jedna drobnostka - to jest czujnik wilgotności i temperatury a nie ciśnienia i temperatury

Hehehe... wiedziałem że gdzieś użyłem słowa 'ciśnienie' ale nie wiedziałem gdzie. Tak to już jest jak się ma mętlik w głowie. Trzeba się w końcu zresetować

W plikach zmienię jak będzie jakaś zmiana dot. działania programu. W wątku już zmieniam.

Dzięki;)

Statystyki: Napisane przez danielos — 29 paź 2016, o 19:06

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T17:18:54+01:00

No i jedna drobnostka - to jest czujnik wilgotności i temperatury a nie ciśnienia i temperatury

Statystyki: Napisane przez buz11 — 29 paź 2016, o 17:18

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T16:14:22+01:00

MikieMan napisał(a):

Dziękuję za podzielenie się swoją pracą, przy okazji przetestuję.

No to czekam na opinię po testach.

buz11 napisał(a):

Biblioteka działa, sprawdziłem na DHT11 Trzeba tylko w pliku ds_dht.c w warunku:
(..)
dopisać sprawdzanie tej sumy

Dzięki za opinię i testy, oraz za znalezienie błędu. Obliczanie tej sumy jest, ale w tym warunku który został troszeczkę źle sformułowany - coś źle musiałem przenieść. Dzięki za znalezieniu tego błędu.

Już poprawiam.

Statystyki: Napisane przez danielos — 29 paź 2016, o 16:14

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T15:33:53+01:00

Hej,

Biblioteka działa, sprawdziłem na DHT11 Trzeba tylko w pliku ds_dht.c w warunku:
[syntax=c]#if DHT == 1

//czy dane zostałe poprawnie odebrane
if(checksum){[/syntax]

dopisać sprawdzanie tej sumy

[syntax=c]#if DHT == 1

//sprawdzenie sumy kontrolnej
uint8_t checksum = ( (read_dht[NEW].indeks[0] + read_dht[NEW].indeks[1] + read_dht[NEW].indeks[2] + read_dht[NEW].indeks[3]) );

//czy dane zostałe poprawnie odebrane
if(checksum){[/syntax]

Statystyki: Napisane przez buz11 — 29 paź 2016, o 15:33

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T08:17:51+01:00

Bardzo ładnie napisana uniwersalna biblioteka
Dziękuję za podzielenie się swoją pracą, przy okazji przetestuję.

Statystyki: Napisane przez MikieMan — 29 paź 2016, o 08:17

Re: Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T07:16:24+01:00

Dzięki kawał dobrej roboty

Statystyki: Napisane przez gufim — 29 paź 2016, o 07:16

Bibioteka dla czujnika wilgotności DHT11/22

2016-10-29T19:08:24+01:00

Witam.

Chciałbym wam przedstawić mój pomysł na obsługę czujnika wilgotności DHT11/DHT22 ( RHT01 / RHT03 / AM2302).

Proszę również o przetestowanie, oraz o ewentualne podpowiedzi co dodać/zmienić.

Biblioteka nie korzysta z delay'ów tylko z timerów sprzętowych i programowych. Do tego celu został wykorzystanie Timer0 który zgłasza przerwanie co 20us (implementacja i konfiguracja wewnątrz biblioteki), oraz dowolnego Timera konfigurowanego przez użytkownika - przerwanie musi być zgłaszane co 10ms.
Bibliotekę przystosowałem do mikrokontrolerów Atmega32 oraz 48, 88, 168 ...
Możliwa praca z kwarcami 10MHz, 11.0592MHz, 14.7456MHz, 16MHz

Funkcja odczytu zwraca wartość średnią z obecnie dokonanego pomiaru, oraz ostatniej wartości średniej.

Minimalny odstęp między pomiarami wg producenta może wynieść 2sekundy.

W pliku nagłówkowym .h wybieramy do którego pinu podpięty jest nasz czujnik, oraz wybieramy rodzaj czujnika (poprzez wpisanie 1 bądź 2 przy #define DHT).

[syntax=c]/*
* ds_dht.h
*
* Created on: 19 paź 2016
*Edited on:28 paź 2016
* Author: Daniel
*
* Obsługa czujników DHT11 / RHT01 / DHT22 / RHT03 / AM2302
*
* Obsługa AVR Atmega8, Atmega32
* Obsługa częstotliwości 10MHz, 11.0592MHz, 14.7456MHz, 16MHz
*
* Biblioteka wykorzystuje przerwanie od timera 0 w trybie CTC co 20us -
* przerwanie skonfigurowane wewnątrz biblioteki.
* Dodatkowo, wykorzystywane jest przerwanie co 10ms, które należy skonfigurowac
* samodzielnie i w obsłudze przerwania umieścić następujący warunek:
*
* if(dht_ms)
*dht_ms--;
*
*
*/

#ifndef DS_DHT_DS_DHT_H_
#define DS_DHT_DS_DHT_H_

/* Wybór PINu oraz PORTu na magistralę 1 przewodową dla DHT11/22*/
#define DHT_PIN PB0
#define DHT_IN PINB
#define DHT_OUT PORTB
#define DHT_DDR DDRB

/*
* Obsługa czujnika DHT11 / RHT01 wybierz 1
* Obsługa czujnika DHT22 / RHT03 / AM2302 wybierz 2
*
*/
#define DHT2

//!!!!!NIE ZMIENIAĆ!!!!!
volatile uint8_t dht_timer;
volatile uint8_t dht_ms;

void ds_init_dht(void);//inicjalizacja mikrokontrolera do obsługi czujnika wilgotności
uint8_t ds_read_dht(uint16_t* humidity, uint16_t* temperature);//odczyt danych

#endif /* DS_DHT_DS_DHT_H_ */[/syntax]

Plik główny wygląda następująco:

[syntax=c]/*
* ds_dht.c
*
* Created on: 19 paź 2016
*Edited on:28 paź 2016
* Author: Daniel
*
*
* Obsługa czujników DHT11 / RHT01 / DHT22 / RHT03 / AM2302
*
* Obsługa AVR Atmega8, Atmega32
* Obsługa częstotliwości 10MHz, 11.0592MHz, 14.7456MHz, 16MHz
*
* Biblioteka wykorzystuje przerwanie od timera 0 w trybie CTC co 20us -
* przerwanie skonfigurowane wewnątrz biblioteki.
* Dodatkowo, wykorzystywane jest przerwanie co 10ms, które należy skonfigurowac
* samodzielnie i w obsłudze przerwania umieścić następujący warunek:
*
* if(dht_ms)
*dht_ms--;
*
*
*
*/

#include
#include

#include "ds_dht.h"

#define DHT_GET_IN ( DHT_IN & (1 << DHT_PIN))
#define DHT_OUT_LOW ( DHT_OUT &= (~(1 << DHT_PIN)) )
#define DHT_OUT_HIGH ( DHT_OUT |= (1 << DHT_PIN) )
#define DHT_DIR_IN ( DHT_DDR &= (~(1 << DHT_PIN )) )
#define DHT_DIR_OUT ( DHT_DDR |= (1 << DHT_PIN) )

#define AVERAGE1
#define NEW0

#if defined (__AVR_ATmega48A__) || (__AVR_ATmega48PA__) || (__AVR_ATmega88A__) || (__AVR_ATmega88PA__) \
|| (__AVR_ATmega168A__) || (__AVR_ATmega168PA__) || (__AVR_ATmega328P__) || (__AVR_ATmega328__)

#define OCR_CTCOCR0A
#define TIMSK_CTC TIMSK0
#define OCIE_CTC OCIE0A

#define TCCR_CTC(TCCR0A |= (1<#define PRE_8(TCCR0B |= (1<#define PRE_64(TCCR0B |= (1<
#elif defined (__AVR_ATmega32__)
#defineOCR_CTC OCR0
#define TIMSK_CTC TIMSK
#define OCIE_CTC OCIE0

#define TCCR_CTC(TCCR0 |= (1<#define PRE_8(TCCR0 |= (1<#define PRE_64(TCCR0 |= (1<
#endif

typedef struct{
uint8_t hum_int;
uint8_t hum_dec;
uint8_t temp_int;
uint8_t temp_frac;
uint8_t checksum;
}t_dht;

typedef union{
uint8_t indeks[5];
t_dht data;
}U_DHT;

U_DHT read_dht[2];//tablica 2 elementowa - wartosc średnia, ostatnia wartosc

//inicjalizacja mikrokontrolera do obsługi czujnika wilgotności
void ds_init_dht(void){

//konfiguracja Timera0 - 20us

#if F_CPU<=8000000
#error "Zła częstotliwość!! Wybierz większą!!"
#error "Bad frequency!!"
#elif F_CPU==10000000
PRE_8;//preskaler 8
TCCR_CTC;//Tryb CTC
OCR_CTC = 24;//co 20us, błąd 0%
#elif F_CPU==11059200
PRE_8;//preskaler 8
TCCR_CTC;//Tryb CTC
OCR_CTC = 26;//co 20us, błąd 2,4%
#elif F_CPU==14745600
PRE_8;//preskaler 8
TCCR_CTC;//Tryb CTC
OCR_CTC = 35;//co 20us, błąd 0,31%
#elif F_CPU==16000000
PRE_64;//preskaler 64
TCCR_CTC;//Tryb CTC
OCR_CTC = 4;//co 20us, błąd 0%
#endif

}

//odczyt wilgotności i temperatury, wynik pomiaru (średni z dwóch)
//umieszczany w danych wejściowych
uint8_t ds_read_dht(uint16_t* humidity, uint16_t* temperature){

uint8_t j=0, i=0;

TIMSK_CTC |= (1<
//procedura startu
DHT_DIR_OUT;
DHT_OUT_HIGH;
DHT_OUT_LOW;

//odczekanie więcej jak 18ms
dht_ms=2;
while(dht_ms);

DHT_OUT_HIGH;

//ustawienie wiejścia
DHT_DIR_IN;

//czekanie na potwierdzenie z czujnika około 10us
dht_timer = 0;
while(DHT_GET_IN){
if(dht_timer>10)//jeżeli w przeciągu 200us nie nastąpi wyjście
return 0;//zgłoś błąd
}

//Potwierdzenie nadawania przez dht - stan niski i wysoki przez 80us
dht_timer = 0;
while(!DHT_GET_IN){//80us stan niski
if(dht_timer>10)//jeżeli w przeciągu 200us nie nastąpi wyjście
return 0;//zgłoś błąd
}

while(DHT_GET_IN){//80us stam wysoki
if(dht_timer>20)//jeżeli w przeciągu 400us nie nastąpi wyjście (kolejne 200us)
return 0;//zgłoś błąd
}

//odczyt danych
//odbiór 5 pakietów danych
for(j=0 ; j<5 ; j++){

//wyzerowanie zmiennej
read_dht[NEW].indeks[j] = 0x00;

for(i=8 ; i > 0 ; ){
--i;//najpierw dekrementacja zmiennej

dht_timer = 0;//wyzeruje licznik

while(!DHT_GET_IN){//najpierw stan niski
if(dht_timer>10)//jeżeli w przeciągu 200us nie nastąpi wyjście
return 0;//zgłoś błąd
}
while(DHT_GET_IN){//następnie stan wysoki
if(dht_timer>20)//jeżeli w przeciągu 400us nie nastąpi wyjście (kolejne 200us)
return 0;//zgłoś błąd
}

//0 logiczne występuje gdy stan niski trwa 50us a stan wysoki 26-28us
//czyli razem około 80us.
//1 logiczna występuje gdy stan niski trwa 50us a stan wysoki 70us
//czyli razem około 120us
if( (dht_timer >= 6) && (dht_timer <=8) ){
//jeżeli czas pomiaru stanu wysokiego i niskiego wyniósł
// od 100us do 160 us to wpisz logiczną jedynkę
read_dht[NEW].indeks[j] |= (1 << i);
}
}
}

dht_timer = 0;
//Zakończenie transmisji sygnalizowane jest stanem niskim trwającym 50us,
//ustawionym przez układ DHT
while(!DHT_GET_IN){//najpierw stan niski
if(dht_timer>10)//jeżeli w przeciągu 200us nie nastąpi wyjście
return 0;//zgłoś błąd
}

//Ustawienie pinu jako wyjście i ustawienie na nim stanu wysokiego
DHT_DIR_OUT;
DHT_OUT_HIGH;

TIMSK_CTC &= ~(1<

//obliczenie sumy kontrolnej
uint8_t checksum = ( (read_dht[NEW].indeks[0] + read_dht[NEW].indeks[1] + read_dht[NEW].indeks[2] + read_dht[NEW].indeks[3]) );

#if DHT == 1

//czy dane zostałe poprawnie odebrane
if(checksum == read_dht[NEW].indeks[4]){

//obliczenie wartości średniej z nowych danych i z ostaniej średniej
for(i=0 ; i < 4 ; i++){
read_dht[AVERAGE].indeks[i] = (read_dht[AVERAGE].indeks[i] + read_dht[NEW].indeks[i]) / 2;
}

//przepisanie do danych wejściowych
*humidity = read_dht[AVERAGE].data.hum_int;
*temperature = read_dht[AVERAGE].data.temp_int;

return 1;

}else
return 0;

#elif DHT == 2

//czy dane zostałe poprawnie odebrane
if(checksum == read_dht[NEW].indeks[4]){

//ciśnienie
uint16_t temp = (read_dht[AVERAGE].indeks[0] << 8) + read_dht[AVERAGE].indeks[1];

//średnia z dwóch pomiarów
temp = ( temp + (read_dht[NEW].indeks[0] << 8) + read_dht[NEW].indeks[1] ) / 2;

//przepisanie do struktury
read_dht[AVERAGE].indeks[0] = ( temp >> 8 ) & 0x00ff;
read_dht[AVERAGE].indeks[1] = ( temp ) & 0x00ff;

//temperatura
temp = ( (read_dht[NEW].indeks[2] << 8) & 0x7f ) + read_dht[NEW].indeks[3];

//zrobienie wartości ujemnej dla nowej wartości
if( read_dht[NEW].indeks[2] & 0x80){
temp = - temp;
}

//średnia z dwóch pomiarów
temp = ( ( (int16_t)temp + (int16_t)(read_dht[AVERAGE].indeks[2] << 8) + (int16_t)read_dht[AVERAGE].indeks[3] ) / 2);

read_dht[AVERAGE].indeks[2] = ( temp >> 8 ) & 0x00ff;
read_dht[AVERAGE].indeks[3] = ( temp ) & 0x00ff;

//przepisanie do danych wejściowych
*humidity = (read_dht[AVERAGE].indeks[0] << 8) + read_dht[AVERAGE].indeks[1];
*temperature = (read_dht[AVERAGE].indeks[2] << 8) + read_dht[AVERAGE].indeks[3];
//czy dane zostałe poprawnie odebrane
if(checksum == read_dht[NEW].indeks[4]){

return 1;
}else{
return 0;
}

#endif

return 0;
}

//Obsługa przerwania co 20us od timera 0
#if defined (__AVR_ATmega48A__) || (__AVR_ATmega48PA__) || (__AVR_ATmega88A__) || (__AVR_ATmega88PA__) \
|| (__AVR_ATmega168A__) || (__AVR_ATmega168PA__) || (__AVR_ATmega328P__) || (__AVR_ATmega328__)
ISR(TIMER0_COMPA_vect){
#elif defined (__AVR_ATmega32__)
ISR(TIMER0_COMP_vect){

#else
#error "Wybierz inny uC"
#endif
dht_timer++;
}[/syntax]

Na początku programu przed pętlą główną należy wykonać inicjalizację biblioteki poprzez funkcję
[syntax=c]ds_init_dht();[/syntax]
(oraz odblokować przerwania - sei() )

Natomiast odczyt z czujnika dokonujemy poprzez funkcję [syntax=c]ds_read_dht( &wilg, &temp);[/syntax], gdzie wilg i temp to zmienne do których będą przepisana wartość wilgotności i temperatury.

Użytkownik tej biblioteki musi skonfigurować we własnym zakresie przerwanie co 10ms i wstawić do obsługi następujący warunek:

[syntax=c]if(dht_ms)
dht_ms--;[/syntax]

Przykładowe użycie:

[syntax=c]char uart_buf[10];

// zmienne - timery programowe
volatile uint8_t Timer1;

uint16_t wilg, temp;

// obsługa timerów programowych
ISR( TIMER2_COMP_vect ) {
uint8_t n;

n = Timer1;/* 1ms Timer1 */
if (n) Timer1 = --n;

//timer dla czujnika wilgotności dht
n = dht_ms;
if(n)
dht_ms = --n;

}

int main(void){

// konfiguracja Timer2 - HeartBeat
TCCR2 |= (1<TCCR2 |= (1<OCR2 = 96;// 10ms
TIMSK |= (1<
ds_init_dht();

//konfiguracja rs232
uart_init(RS_UBRR);

sei();

uint8_t ch;

while(1){

if(!Timer1){

Timer1 = 200;//co 2s

ch = ds_read_dht( &wilg, &temp);

//czy odebrane dane były poprawne
if(ch==1)
uart_text_P(PSTR("OK!\n\r"));

//wyświetlenie wilgotności
itoa(wilg,uart_buf,10);
uart_text(uart_buf);
uart_text_P(PSTR("\n\r"));

//wyświetlenie temperatury
itoa(temp,uart_buf,10);
uart_text(uart_buf);
uart_text_P(PSTR("\n\n\r"));

}

}

}[/syntax]

To by było chyba na tyle.
Proszę o opinie i testowanie. Jeżeli coś jest nie tak to pisać. Wszystkie informacje będą przydatne.

Pozdrawiam.

-----
Edytowano 29-10-2016: Poprawa kodu i uaktualnienie plików do pobrania

Statystyki: Napisane przez danielos — 28 paź 2016, o 21:07