Feuchtigkeitssensor mit DHT11 und PIC16F1826

[Dominic (oepfel)]

Hallo Leute,

ich versuche, einen Feuchtigkeitssensor (DHT11) für das Badezimmer zu 
entwickeln. Wenn der Feuchtigkeitssensor einen bestimmten Wert erreicht, 
sollte eine LED aufleuchten, um dies anzuzeigen.

Ich hatte geplant, dafür einen PIC16F1826 zu verwenden, aber da ich ein 
PIC-Anfänger bin, habe ich zuerst ein Arduino Uno benutzt. Dort hat das 
Programm mit einer Bibliothek gut funktioniert. Aber mit dem PIC musste 
ich den Wert mit einer selbst konstruierten Methode messen, was ich auch 
getan habe. Zuerst habe ich ein Programmierset mit dem PIC18F45K22 
verwendet, was ebenfalls gut funktionierte.

Aber jetzt, mit meiner eigenen Schaltung und der Verwendung des 
PIC16F1826 (ohne Peripheriegeräte des Programmiersets), habe ich ein 
Problem, den Sensorwert zu lesen. Das Merkwürdige ist, dass ich 
denselben Code zum Lesen der Daten verwendet habe wie beim 
Programmierset.

Zuerst habe ich den internen Oszillator verwendet, aber ich habe keine 
Daten erhalten. Dann habe ich versucht, einen Oszillator von 10 MHz 
anzuschließen, weil ich dachte, der interne wäre für diesen Zweck zu 
ungenau. Aber auch diesmal habe ich keine Daten erhalten.

Ich habe sogar versucht, den Oszillator zu testen, indem ich die LED 
regelmäßig blinken ließ, und das Blinken sah gut aus, soweit ich das von 
Auge aus beurteilen konnte.

Also bitte ich euch jetzt um Hilfe.

Ich habe einige Vermutungen, die euch vielleicht weiterhelfen:

- Vielleicht habe ich die Konfigurationsbits durcheinandergebracht, da 
es das erste Mal war, dass ich dies getan habe.
- Vielleicht gibt es auch ein Problem mit der Oszillatorschaltung.


Unten sind der Code und das Schema der Schaltung aufgeführt.

Zum besseren Verständnis des Fehlers: Ich erhalte aus meinem Code die 
Daten 0 für die Variable "int_RH".

Danke für eure Hilfe.


Code PIC16F1826:

#include <xc.h>
#include <stdbool.h>
#include <stdint.h>
#define _XTAL_FREQ 10000000 // external oscillator frequency of 10MHz
#define LOOP_DELAY 1        // Loop-Delay in ms (milliseconds)
#define WARN_LED LATBbits.LATB0
#define SENSOR PORTBbits.RB1
uint8_t Read_DHT ( uint8_t *data );
void setup ( void )
{
    OSCCON = 0b01111000; // use external oscillator 
    ANSELB = 0x00; // PORTB to digital
    TRISBbits.TRISB0 = 0; // LED as OUTPUT
    TRISBbits.TRISB1 = 0; // Sensor as output
    WARN_LED = 0;   // LED off
}
void loop ( void )
{
    uint8_t data[5] = { 0 };
    uint8_t result = Read_DHT( data );
    if ( result == 0 )
    {
        uint8_t int_RH = data[0];
        uint8_t dec_RH = data[1];
        uint8_t int_T = data[2];
        uint8_t dec_T = data[3];
        
        
        
        if ( int_RH > 1 )
        {
            WARN_LED = 1;
        }
        else
        {
            WARN_LED = 0;
        }
    }
}
void main ( void )
{
    setup( );
    while ( 1 )
    {
        loop( );
        __delay_ms( LOOP_DELAY );
    }
}
uint8_t Read_DHT ( uint8_t *data )
{
    TRISBbits.TRISB1 = 0; // Sensor as output
    LATBbits.LATB1 = 0;
    __delay_ms( 18 );
    LATBbits.LATB1 = 1;
    __delay_us( 40 );
    TRISBbits.TRISB1 = 1; // Sensor aas input
    uint16_t timeout = 10000;
    while ( SENSOR == 1 )
    {
        if ( --timeout == 0 )
        {
            return 0xFF;
        }
    }
    timeout = 10000;
    while ( SENSOR == 0 )
    {
        if ( --timeout == 0 )
        {
            return 0xFF;
        }
    }
    timeout = 10000;
    while ( SENSOR == 1 )
    {
        if ( --timeout == 0 )
        {
            return 0xFF;
        }
    }
    for ( uint8_t i = 0; i < 5; i++ )
    {
        for ( int8_t j = 7; j >= 0; j-- )
        {
            timeout = 10000;
            while ( SENSOR == 0 )
            {
                if ( --timeout == 0 )
                {
                    return 0xFF;
                }
            }
            uint8_t signal_counter = 0;
            timeout = 10000;
            while ( SENSOR == 1 )
            {
                signal_counter++;
                __delay_us( 1 );
                if ( signal_counter > 100 )
                {
                    return 0xFE;
                }
            }
            if ( signal_counter > 30 )
            {
                data[i] |= (1 << j);
            }
        }
    }
    if ( ( uint8_t ) (data[0] + data[1] + data[2] + data[3]) != data[4] )
    {
        return 0xFF;
    }
    return 0;
}

Configurations Bits:

// PIC16F1826 Configuration Bit Settings
// 'C' source line config statements
// CONFIG1
#pragma config FOSC = HS        // Oscillator Selection (LP Oscillator, Low-power crystal connected between OSC1 and OSC2 pins)
#pragma config WDTE = OFF       // Watchdog Timer Enable (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable (PWRT disabled)
#pragma config MCLRE = ON      // MCLR Pin Function Select (MCLR/VPP pin function is digital input)
#pragma config CP = OFF         // Flash Program Memory Code Protection (Program memory code protection is disabled)
#pragma config CPD = OFF        // Data Memory Code Protection (Data memory code protection is disabled)
#pragma config BOREN = ON      // Brown-out Reset Enable (Brown-out Reset disabled)
#pragma config CLKOUTEN = OFF   // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin)
#pragma config IESO = OFF       // Internal/External Switchover (Internal/External Switchover mode is disabled)
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable (Fail-Safe Clock Monitor is disabled)
// CONFIG2
#pragma config WRT = OFF        // Flash Memory Self-Write Protection (Write protection off)
#pragma config PLLEN = OFF      // PLL Enable (4x PLL disabled)
#pragma config STVREN = ON      // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset)
#pragma config BORV = LO        // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.)
#pragma config DEBUG = OFF      // In-Circuit Debugger Mode (In-Circuit Debugger disabled, ICSPCLK and ICSPDAT are general purpose I/O pins)
#pragma config LVP = OFF        // Low-Voltage Programming Enable (High-voltage on MCLR/VPP must be used for programming)
// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.
#include <xc.h>

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dominic schrieb:
> Also bitte ich euch jetzt um Hilfe.
Hast du ein Oszilloskop zur Hand, mit dem du einfach mal messen kannst, 
ob auf dem Interface das Protokoll sowohl pegelmäßig als auch vom Timing 
her so läuft, wie der Sensor es laut Datenblatt braucht?

Das Debuggen serieller Schnittstellen ohne Oszilloskop (oder wenigstens 
so einem 10€-Saleae-Logikanalyzer-Nachbau) ist wie "Autofahren nach 
Gehör": wenn es scheppert hats irgendein Problem gegeben.


BTW: diesen Schaltplan hättest du besser als PNG-Screenshot hier 
angehängt.

[Dominic (oepfel)]

Hi Lothar

Habe leider selber keines, aber kann vielleicht eins von einem Freund 
ausleihen.

Sollte ich dann lieber den Ablauf der Sensorabfrage überprüfen oder 
reicht es auch, z.B. ein 1 Hz Signal zu überprüfen.

Zudem wie viel Toleranz wäre für die Signale maximal erlaubt?

Ach ja und Danke für den Tipp mit dem PNG!

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dominic schrieb:
> Sollte ich dann lieber den Ablauf der Sensorabfrage überprüfen
Der Sensor erwartet ein Signal, das so aussieht, wie es im Datenblatt 
des Sensors steht. Das ist es also, was du überprüfen musst.

> Zudem wie viel Toleranz wäre für die Signale maximal erlaubt?
Genau das sollte im Datenblatt des Sensors stehen. Dort gibt es eine 
Sammlung von Datenblättern zu diesem Sensor:
- https://semiconductors.es/datasheet/DHT11.html

Allerdings sind die chinesischen Datenblätter oft völliger Schrott. Und 
so offenbar auch bei diesem Bauteil, wo das Timing nicht vernünftig mit 
min/typ/max Werten und Schaltpegeln spezifiziert ist. Und das, was 
irgendwie "spezifiziert" ist, steht verstreut in irgendwelchen Bildchen. 
Grauenhaft.

Letztlich hilft dann nur, möglichst nah am "Soll"-Bildchen zu bleiben.

[Dominic (oepfel)]

Also ich habe den Ablauf mal mit dem Oszilloskop gemessen.
Am Anfang sendet der PIC für 18 us ein 0V/Low-Signal, was er auch machen 
soll.

Darauf folgt ein Signal, welches zuerst auf 5V/High geht. Nach kurzer 
Zeit jedoch fällt dieses auf ca. 1V herab (siehe Bild)

Es sieht mir sehr danach aus, dass dies der eigentliche Fehler ist.

Nichtsdestotrotz folgen darauf allerdings noch High und Low Signale des 
Sensors, wobei diese nicht ganz ankommen.

Ich konnte leider noch nicht mehr Messungen aufstellen, werde aber 
versuchen noch mehr Messungen durchzuführen.

[Dominic (oepfel)]

Hier noch das Zeitdiagramm für das auslesen des DHT11

[Peter K. (Firma: www.pic-microcontroller.de) (peter_k)]

Hier mal ein Code Schnipsel für einen anderen Controller.
Vielleicht hilft es dir weiter.
Hier werden Temperatur und Feuchte ausgelesen.

unsigned short  Check, Temp, RH, Sum, Ch ;
void StartSignal(){
 TRISIO.F2 = 0;    //Configure TRISIO.F2 as output
 GPIO.F2 = 0;    //GP2 sends 0 to the sensor
 delay_ms(18);
 GPIO.F2 = 1;    //GP2 sends 1 to the sensor
 delay_us(30);
 TRISIO.F2 = 1;  //Configure TRISIO.F2 as input
  }
 //////////////////////////////
 void CheckResponse(){
 Check = 0;
 delay_us(40);
 if (GPIO.F2 == 0){
 delay_us(80);
 if (GPIO.F2 == 1)   Check = 1;   delay_us(40);}
 }
 //////////////////////////////
 char ReadData(){
 char i, j;
 for(j = 0; j < 8; j++){
 while(!GPIO.F2); //Wait until GP2 goes HIGH
 delay_us(30);
 if(GPIO.F2 == 0)
       i&= ~(1 << (7 - j));  //Clear bit (7-b)
 else {i|= (1 << (7 - j));  //Set bit (7-b)
 while(GPIO.F2);}  //Wait until GP2 goes LOW
 }
 return i;
 }
 //////////////////////////////
 void main() {
  Serial_Lcd_Init();                 // LCD display initialization
  Serial_Lcd_Cmd(_LCD_CURSOR_OFF);        // cursor off
  Serial_Lcd_Cmd(_LCD_CLEAR);             // clear LCD
  while(1){
  StartSignal();
  CheckResponse();
  if(Check == 1){
  RH = ReadData();
  ReadData();
  Temp = ReadData();
  ReadData();
  Sum = ReadData();
  if(Sum == (RH + Temp)){
  Serial_Lcd_Out(1, 6, "T:  C");
  Serial_Lcd_Out(2, 6, "H:  %");
  Serial_LCD_Chr(1, 8, 48 + ((Temp / 10) % 10));
  Serial_LCD_Chr(1, 9, 48 + (Temp % 10));
  Serial_LCD_Chr(2, 8, 48 + ((RH / 10) % 10));
  Serial_LCD_Chr(2, 9, 48 + (RH % 10));
  }
  else{
  Serial_Lcd_Cmd(_LCD_CLEAR);
  Serial_Lcd_Out(1, 6, "Error");}
    }
  else {
  Serial_Lcd_Cmd(_LCD_CLEAR);
  Serial_Lcd_Out(1, 6, "Error");
  }
  delay_ms(1000);
  }
 }

Mod: die [c] Tags das nächste Mal bitte selber um den Quelltext machen

[Jens G. (jensig)]

Dominic schrieb:
> Darauf folgt ein Signal, welches zuerst auf 5V/High geht. Nach kurzer
> Zeit jedoch fällt dieses auf ca. 1V herab (siehe Bild)

Lt. DB des Sensors sollen da 5,1k als PullUp gegen Ub gehen, Du hast 
aber 1k. Vielleicht ist der Strom einfach etwas zu hoch für den 
OC-Ausgang, so daß er da ein sattes Volt hat ...
Sollte aber trotzdem noch kein Problem sein, da der PIC das immer noch 
als L zählen dürfte.
Ansonste ist es immer Mist, nur einen kleinen Ausschnitt des 
Oszillograms zu zeigen. Zeig doch mal die ganze Sequence beginnend mit 
dem Startsignal (zumindest noch einige relevante Pulse nach dem Start, 
solange das sinnvoll auf den Oszischirm paßt)

[Stephan S. (uxdx)]

Ich möchte etwas grundsätzliches zu den DHTxx-Sensoren sagen: das sind 
nur Schätzeisen, wenn die länger höhere Rh sehen, dann bleiben die auf 
100%. Man kann die zwar mit dem Fön regenerieren, das hält aber nicht 
lange.

Ich habe daher alle DHTxx rausgeworfen und durch SHT31 bzw. jetzt SHT41 
ersetzt, die wollen allerdings I2C aber das ist ja auch kein Problem.

[Joachim B. (jar)]

Dominic schrieb:
> ich versuche, einen Feuchtigkeitssensor (DHT11) für das Badezimmer zu
> entwickeln.

dumme Zwischenfrage, warum DHT11 wo doch der DHT22 genauer ist und man 
am den genauso lernen kann.

[Dominic (oepfel)]

> dumme Zwischenfrage, warum DHT11 wo doch der DHT22 genauer ist und man
> am den genauso lernen kann.

Hab ihn nur genommen, weil ich ihn schon hatte, aber Danke für die Info

Zurück aber zum wesentlichen:
Ich habe erneut Messungen durchgeführt in "Bild 1" ist der gesamte 
Ablauf des "Korrekten Signals" zu sehen.

In "Bild 2" sind zeitlichen Abläufe, welche vom PIC an den DHT11 gehen 
noch einmal klar dargestellt.

Das zweite Signal vom PIC (das High Signal) wird aber etwas falsch 
ausgegeben, siehe "Bild 3".

In den Bildern 4, 5 und 6 sind nun die drei nächsten Signale zu sehen. 
Wobei soweit ich es verstanden habe, die ersten zwei als Start-Signal 
vom DHT11 aus gesendet werden.


Nun ist mir aber noch etwas weiteres aufgefallen, nämlich tritt so eine 
"korrekte Signalübertragung" gar nicht immer auf. Denn wie im "Bild 7" 
zu sehen ist, kommen manchmal auch nur Signale, welche nur für 18 ms auf 
low gehen und dann wieder auf high bleiben. (Für präzisere Zeitanzeige 
siehe "Bild 8")

Ich habe deshalb einmal den Code noch so umgeschrieben, dass wenn einmal 
eine "Korrekte Messung stattgefunden hat. Was geprüft wird indem ein 
Wert höher als 1 registriert wurde, dass der Code dann in einer while 
hängen bleibt und die LED durchgehend leuchtet. Jedoch aber ohne Erfolg 
die LED zum Leuchten zu bringen.

Hat jemand einen Lösungsansatz?

[Dominic (oepfel)]

Im Anhang wären noch alle weiteren Bilder der Messungen welche ich 
gemacht habe...

[Helmut -. (dc3yc)]

Fast 36MB für relativ unsinnige Bilder?

[Jens G. (jensig)]

Dominic schrieb:
> Nun ist mir aber noch etwas weiteres aufgefallen, nämlich tritt so eine
> "korrekte Signalübertragung" gar nicht immer auf. Denn wie im "Bild 7"
> zu sehen ist, kommen manchmal auch nur Signale, welche nur für 18 ms auf
> low gehen und dann wieder auf high bleiben. (Für präzisere Zeitanzeige
> siehe "Bild 8")

Du scheinst offensichtlich immer exakt 18ms als Startsignal zu 
verwenden. Das ist Blödsinn, denn der DHT will >18ms haben, und nicht 
exakt 18ms, so daß es auch gar keine Not gibt, die 18ms genau einhalten 
zu wollen. Damit hängst Du immer an der Start-Detektionsgrenze des DHT, 
so daß er offensichtlich gerne auch etliche Startsignale übersieht, was 
Du dann wohl auch im Bild 7 siehst.
Zumal der DHT es mit dem Timing der Pulse selber nicht so genau nimmt, 
sondern offensichtlich leicht "nachgeht". Sieht man ja an deinen 
Messungen, die immer leicht über den DB-Angaben liegen. Also solltest Du 
beim Startsignal auch entsprechend mindestens leicht drüber liegen.
Nimm einfach >25ms Start, und gut ...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Helmut -. schrieb:
> st 36MB für relativ unsinnige Bilder?
(Kamera)fotos von irgendwas bitte immer(!) als JPEG posten. Auch wenn 
sie "Screenshots" ersetzen. Und richtige Screenshots von digital 
erzeugten Bildern (Coumputer- und Bedienoberflächen) dann besser als 
PNG. Man sollte das Werkzeug namens "Bildformat" schon kennen und wissen 
welches Bildformat das richtige Tool für welchen Zweck ist.

BTW: mein Rigol 4-Kanal-Oszi hat einen USB-Slot für genau solche 
Screenshots. Tolle Sache.

[Dominic (oepfel)]

Ich habe jetzt einmal den ersten Delay auf 25 ms geändert, jedoch ohne 
Erfolg.

Deshalb habe ich den Code einmal etwas umgeändert, so dass ich während 
des Debuggen sehen kann bei welcher Stelle er die Funktion "Read_DHT" 
verlässt (siehe Code unten)

Im ersten Durchlauf beim Debuggen bekomme ich den Rückgabewert 0xFA.

Ab dann bekomme ich nach jedem Durchlauf den Rückgabewert 0x00, was 
eigentlich gut ist und bedeutet, dass das Messen des Sensors erfolgreich 
war. Jedoch ist in jedem der fünf Variablen des Arrays data[0]...data[4] 
0x00 hinterlegt.

Ich habe darauf noch das zweite Delay von ursprünglich 40 us auf 30 us 
geändert, da im DB steht dieses Delay soll zwischen 20 us - 40 us 
liegen. Aber auch dies lieferte mir die gleichen Ergebnisse.

Hat jemand eine Idee woran das liegen könnte.

#include <xc.h>
#include <stdbool.h>
#include <stdint.h>

#define _XTAL_FREQ 10000000 // external oscillator frequency of 10MHz

#define LOOP_DELAY 1        // Loop-Delay in ms (milliseconds)


#define WARN_LED LATBbits.LATB0
#define SENSOR PORTBbits.RB1



uint8_t Read_DHT ( uint8_t *data );

void setup ( void )
{
    OSCCON = 0b01111000; // use external oscillator 

    ANSELB = 0x00; // PORTB to digital

    TRISBbits.TRISB0 = 0; // LED as OUTPUT

    TRISBbits.TRISB1 = 0; // Sensor as output

    WARN_LED = 0;   // LED off

}

void loop ( void )
{

    uint8_t data[5] = { 0 };

    uint8_t result = Read_DHT( data ); // Breakpoint is here
    if ( result != 0 )
    {
        uint8_t int_RH = data[0];
        uint8_t dec_RH = data[1];
        uint8_t int_T = data[2];
        uint8_t dec_T = data[3];


        if ( int_RH > 1 )
        {
            WARN_LED = 1;
        }
        else
        {
            WARN_LED = 0;
        }
    }
}

void main ( void )
{
    setup( );

    while ( 1 )
    {
        loop( );
        __delay_ms( LOOP_DELAY );

    }
}

uint8_t Read_DHT ( uint8_t *data )
{


    TRISBbits.TRISB1 = 0; // Sensor as output
    LATBbits.LATB1 = 0;
    __delay_ms( 25 );

    LATBbits.LATB1 = 1;
    __delay_us( 30 );

    TRISBbits.TRISB1 = 1; // Sensor a   n s input

    uint16_t timeout = 10000;
    while ( SENSOR == 1 )
    {
        if ( --timeout == 0 )
        {
            return 0xFA;
        }
    }

    timeout = 10000;
    while ( SENSOR == 0 )
    {
        if ( --timeout == 0 )
        {
            return 0xFB;
        }
    }

    timeout = 10000;
    while ( SENSOR == 1 )
    {
        if ( --timeout == 0 )
        {
            return 0xFC;
        }
    }

    for ( uint8_t i = 0; i < 5; i++ )
    {
        for ( int8_t j = 7; j >= 0; j-- )
        {
            timeout = 10000;
            while ( SENSOR == 0 )
            {
                if ( --timeout == 0 )
                {
                    return 0xFD;
                }
            }
            uint8_t signal_counter = 0;
            timeout = 10000;
            while ( SENSOR == 1 )
            {
                signal_counter++;
                __delay_us( 1 );
                if ( signal_counter > 100 )
                {
                    return 0xFE;
                }
            }

            if ( signal_counter > 30 )
            {
                data[i] |= (1 << j);
            }
        }
    }

    if ( ( uint8_t ) (data[0] + data[1] + data[2] + data[3]) != data[4] )
    {
        return 0xFF;
    }

    return 0;
}

[Joachim B. (jar)]

Dominic schrieb:
> (siehe Code unten)

Wichtige Regeln - erst lesen, dann posten!
Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

willst du mein Scrollrad zerstören?
abgesehen davon, welchen Nutzhwert haben die ganzen Leerzeilen?

[Dominic (oepfel)]

Hatte es schon gelesen, dachte aber, dass dieser Code nicht zu lange 
war...

Deshalb hier noch für alle die nicht scrollen wollen ;D

[Klaus F. (klaus27f)]

Hallo,
dein spezieller Code, viiile Leerzeilen, x-mal 10000 "timeout", dazu die 
"Messungen" mit 36 Mbyte .png Bildern (Fotos von einem Scope welches 
echte Screenshots kann,  --- nur noch abpausen auf Butterbrotpapier wäre 
besser ---), alles recht sehr viel eigen... Ohh ohhhhh ohhhhhhhhhhh!

Kaum mehr auszuhalten...

Daher habe ich jetzt zu später Stunde im WWW ein besseres Beispiel 
gesucht und hoffentlich auch gefunden.
Bitte das auf deinen uC anpassen und probieren.

https://brainly.com/question/40429058

Und nur noch regelkonforme Meldungen hier posten.

[Joachim B. (jar)]

was soll?

    while (1)
    uint8_t data[5] = { 0 };


entweder fehlt eine öffnende Klammer { oder ich verstehe PIC C nicht

Klaus F. schrieb:
> viiile Leerzeilen,

dies fragte ich auch ohne Antwort.

[Dominic (oepfel)]

War leider der falsche Anhang.

Und es tut mir unendlich leid für die ganzen Anfängerfehler...