Mehrere Temperatursensoren mit einem Raspberry Pi

Ich habe viele Beispiele für die Verwendung eines Temperatursensors mit dem Raspberry Pi gesehen. Wie kann ich jedoch 5-6 Temperatursensoren mit einem Raspberry Pi multiplexen? Ich möchte die Temperatur von mehreren Quellen gleichzeitig ablesen.

Kann ich einfach die GPIO-Pins auf dem Raspberry Pi zuweisen, um von jedem Sensor zu lesen, wobei im Wesentlichen die gleiche Konfiguration für einen Sensor repliziert wird, oder benötige ich eine Art Multiplexer, an den alle Sensoren dann wiederum Daten parallel senden würden zum Raspberry Pi?

Vorausgesetzt, Ihr Sensor ist ein DS18B20, und es ist ein 1-Draht-Schaltkreis, und 1-Draht ist ein Protokoll, das mehrere Adressen auf demselben Bus ausführen kann, und das 1-Draht-Temperaturkernmodul kann bis zu 10 Temperatursensoren lesen im selben Bus. (Überprüfen Sie Zeile 49 des Treiberquellcodes ).

Wenn Sie nur 10 Ihrer Sensoren an die gleichen 3 Pins anschließen (3v3, GND und den 1-Draht-E / A-Pin - das ist Pin Nummer 4 auf dem Stecker (dies ist im Treiber fest codiert!) Und Sie werden ihre Ausgänge von / lesen sys / bus / w1 / devices / 28 * / w1_slave, wobei 28 * die individuelle, eindeutige 1-Draht-Adresse ist. Überprüfen Sie das hervorragende Lernprogramm von adafruit . Vergessen Sie nicht, dass der 4K7-Widerstand den Datenstift hochzieht (Nummer 4 - NUR EINE!). Da das interne Hochziehen des Pi ungefähr 50 K ergibt und dies für den Sensor zu viel ist, benötigen Sie diese zusätzliche Komponente.

Sie sollten nur sicherstellen, dass Sie nicht versuchen, parasitäre Energie zu verwenden. Wenn Sie die 3 Pins aller Geräte verbinden, sollte es Ihnen gut gehen.

Als Referenz finden Sie hier einen kurzen Ausschnitt aus Python, um den 1-Draht-GPIO zu bitbangen und den Temperaturmesswert für den ersten Sensor zurückzugeben. Es sollte einfach genug sein, Änderungen vorzunehmen, um die Temps für alle angeschlossenen Sensoren als Liste oder ähnliches zurückzugeben.

import subprocess, time

def read_onewire_temp():
    '''
    Read in the output of /sys/bus/w1/devices/28-*/w1_slave
    If the CRC check is bad, wait and try again (up to 20 times).
    Return the temp as a float, or None if reading failed.
    '''
    crc_ok = False
    tries = 0
    temp = None
    while not crc_ok and tries < 20:
        # Bitbang the 1-wire interface.
        s = subprocess.check_output('cat /sys/bus/w1/devices/28-*/w1_slave', shell=True).strip()
        lines = s.split('\n')
        line0 = lines[0].split()
        if line0[-1] == 'YES':  # CRC check was good.
            crc_ok = True
            line1 = lines[1].split()
            temp = float(line1[-1][2:])/1000
        # Sleep approx 20ms between attempts.
        time.sleep(0.02)
        tries += 1
    return temp

Das Sprechen über einen 1-Draht-Bus kann schmerzhaft sein. Egal, ob Sie mit 1 Sensor oder 100 sprechen, Sie müssen über das Timing nachdenken. Ich habe vor ein paar Jahren einen Code für den DS18B20 geschrieben, aber er befindet sich in der Assembly. Wenn es von Nutzen ist, hier:

;***************************************************************
;Title:     Temperature Logger
;Description:   Polls temperature every two seconds and returns a value
;       in degC as well as the slope (rising, falling, steady)
;***************************************************************
Screen  EQU $F684
;System Equates
PortA   EQU $0000
DDRA    EQU $0002
;Program Equates
TxPin   EQU %00000001
RxPin   EQU %00000010
IntPin  EQU %10000000
;Commands
SkipROM EQU $CC
Convert EQU $44
ReadPad EQU $BE
;Constants
ASCII_0 EQU 48
Poll_D  EQU 2000
;Macros
TxOn    macro    ; Send the 1-wire line Low
    MOVB    #TxPin,DDRA
    MOVB    #$00,PortA
    endm

TxOff   macro    ;Releases the 1-wire line letting it return to High.
    MOVB    #$00,DDRA
    endm


;-------------------------------------
;Main 
;-------------------------------------
    ORG $0D00

        ; Clear registers and initialise ports
Start:  MOVB    #$00, DDRA
Main:   LDD     #$00
        JSR     Init
        LDAA    #SkipROM
        JSR     Write
        LDAA    #Convert
        JSR     Write
        JSR     Wait
        JSR     Init
        LDAA    #SkipROM
        JSR     Write
        LDAA    #ReadPad
        JSR     Write
        JSR     Read    ; read first 8 bits
        TFR     A, B
        JSR     Read    ; read second 8 bits
        ; Convert bytes to BCD
        LSRB
        LSRB
        LSRB
        LSRB
        STD     TempNew
        PSHA
        PSHB
        LDAB    #6
        MUL
        TBA
        PULB
        ABA
        CLRB
Conv_Lp:SUBA    #10
        BMI     Conv_Dn
        INCB
        BRA     Conv_Lp
Conv_Dn:ADDA    #10
        TFR     A, Y
        PULA
        ABA
        TFR     Y, B
        ; convert BCD bytes to ASCII and store in temp register
        LDX     #Temp
        ADDA    #ASCII_0
        STAA    0, X
        INX
        ADDB    #ASCII_0
        STAB    0, X
        LDX     #OutUp  ; print 'The current temp is '
        JSR     Echo
        LDX     #Temp   ; print ASCII bytes
        JSR     Echo
        ; compare stored temp with previously stored and print 'rising', 'falling' or 'steady'
        LDD     TempNew
        SUBD    TempOld
        BGT     Rising
        BEQ     Same
        LDX     #Fall
        BRA     EchDir
Rising: LDX     #Rise
        BRA     EchDir
Same:   LDX     #Steady
EchDir: JSR     Echo
        ; wait 2 seconds
        LDX     #Poll_D
Bla_Lp: JSR     Del1ms
        DBNE    X, Bla_Lp
        ; set new temp as old temp and loop
        LDD     TempNew
        STD     TempOld
        JMP     Main
        SWI


;-------------------------------------
;Subroutines
;-------------------------------------
Init:   TxOn        ; turn pin on
        uDelay  500 ; for 480us
        TxOff       ; turn pin off
        uDelay  70  ; wait 100us before reading presence pulse
        JSR Wait
        RTS
Wait:   LDX #120
Wait_Lp:JSR Del1ms
        DBNE    X, Wait_Lp
        RTS

Write:  PSHX
        PSHA
        LDX     #8  ; 8 bits in a byte
Wr_Loop:BITA    #%00000001
        BNE     Wr_S1   ; bit is set, send a 1
        BEQ     Wr_S0   ; bit is clear, send a 0
Wr_Cont:LSRA    ; shift input byte
        uDelay  100
        DBNE    X, Wr_Loop  ; shifted < 8 times? loop else end
        BRA     Wr_End
Wr_S1:  TxOn    ; on for 6, off for 64
        uDelay  6
        TxOff
        uDelay  64
        BRA     Wr_Cont
Wr_S0:  TxOn    ; on for 60, off for 10
        uDelay  60
        TxOff
        uDelay  10
        BRA     Wr_Cont
Wr_End: PULA
        PULX
        RTS

Read:   PSHB
        LDAB    #%00000001
        CLRA
Rd_Loop:TxOn    ; on for 6, off for 10
        uDelay  6
        TxOff
        uDelay  10
        BRSET   PortA, #RxPin, Rd_Sub1  ; high? add current bit to output byte
Rd_Cont:uDelay  155 ; delay and shift.. 0? shifted 8 times, end
        LSLB
        BNE     Rd_Loop
        BRA     Rd_End
Rd_Sub1:ABA 
        BRA     Rd_Cont
Rd_End: PULB
        RTS

uDelay  macro    ;Delay a mutliple of 1us (works exactly for elays > 1us)
        PSHD
        LDD   #\1
        SUBD  #1
        LSLD
\@LOOP  NOP
        DBNE  D, \@LOOP
        PULD
        endm

;-------------------------------------
;General Functions
;-------------------------------------
; delays
Del1us: RTS

Del1ms: PSHA
        LDAA    #252
Del_ms: JSR     Del1us
        JSR     Del1us
        JSR     Del1us
        CMPA    $0000
        CMPA    $0000
        NOP
        DECA
        BNE     Del_ms
        CMPA    $0000
        NOP
        PULA
        RTS

; display text from address of X to \0
Echo:   PSHY
        PSHB
        LDAB    0, X
Ech_Lp: LDY Screen
        JSR 0, Y
        INX
        LDAB    0, X
        CMPB    #0
        BNE Ech_Lp
        PULB
        PULY
        RTS

Interrupt:
        SWI
        RTI

;-------------------------------------
;Variables
;-------------------------------------
    ORG   $0800
OutUp:  DC.B    'The current temperature is ', 0
Rise:   DC.B    ' and Rising', $0D, $0A, 0
Steady: DC.B    ' and Steady', $0D, $0A, 0
Fall:   DC.B    ' and Falling', $0D, $0A, 0
Temp:   DS  2
    DC.B    0
TempOld:DS  2
TempNew:DS  2

Bei Interesse hier ein Leitfaden zur Verwendung eines DS18B20-Temperatursensors (der wie oben angegeben mit so vielen GPIO-Pins auf dem Pi verkettet werden kann, wie Sie möchten) mit einem Himbeer-Pi und einem Pyhton-Code, der ihn an einen sendet RESTful-Service, der die Temperaturen in Diagrammen und Diagrammen auf einer Website zusammenfasst und anzeigt. Der gesamte Code für das angegebene GitHub-Konto ist öffentlich. http://macgyverdev.blogspot.se/2014/01/weather-station-using-raspberry-pi.html

Welche Art von Temperatursensor verwenden Sie? Wenn Sie so etwas wie einen DS18B20 haben, können Sie bis zu 18446744073709551615 Sensoren verketten, wenn Sie so viele hatten.

Antworten:

Wie kann ich 5-6 Temperatursensoren auf einen Raspberry Pi multiplexen?

Es gibt Zusatzmodule, die Sie erhalten können und die über mehrere Busse verfügen, um eine Verbindung zum Pi herzustellen.
In diesem Video werden ihre Geschwindigkeiten verglichen: https://www.youtube.com/watch?v=YbWidNBycls Er verwendet schließlich einen neu kompilierten Kernel, um mehrere GPIOs für die Kommunikation mit mehreren Sensoren zu erhalten. Er hat seine Ergebnisse nicht darüber veröffentlicht, wie er darauf gekommen ist. Es ist jedoch möglich, es zu multiplexen, anstatt nur einen Pin zu verwenden.

Aktualisieren. Er hat jetzt gepostet. Er hat 81 Sensoren an 9 separate GPIO angeschlossen und konnte alle Temperaturen in weniger als 3 Sekunden abrufen : https://www.youtube.com/watch?v=JW9wzbp35w8

Die ideale Methode zum Auslesen mehrerer Sensoren ist die Verwendung von I2C-Sensoren.

Dies ist die einzige Möglichkeit, mehrere Sensoren miteinander zu verketten oder analoge Sensoren zu verwenden, die jedoch viele analoge Pins belegen, während i2c nur zwei Leitungen verwendet. Nehmen wir an, Sie verwenden Pi2 / 3, dann schlage ich vor, einen Himbeer-Pi-Hut mit I2C-Anschluss zu kaufen, damit Sie alle Ihre i2c-Geräte innerhalb von Sekunden mit Pi verbinden und sicherstellen können, dass Ihre Hardware korrekt ist.

Jetzt musst du den Pi mit einem I2C-Adapter über den Sensorteil bewegen lassen. TI, AD, NXP, Freescale und viele andere Unternehmen stellen Temperatursensoren mit I2C her, aber Sie möchten mehr als einen Sensor anschließen, sodass es zwei Möglichkeiten gibt.

1. Sie erhalten 6 verschiedene I2C-Sensoren mit unterschiedlichen I2C-Adressen. Wenn Sie zwei Sensoren mit derselben Adresse haben, funktioniert dies nicht.

2. Sie können Sensoren mit Adresszeile erhalten und einfach die Adresse ändern und Sie können sie mit Pi ohne Adressenkonflikt verbinden. Ich schlage vor, diesen TMP 100-Sensor zu verwenden. Ich bevorzuge diesen, da er 2 Adressleitungen mit Unterstützung für potentialfreie Adressleitungen hat, sodass Sie 6 Sensoren mit einer i2c-Leitung verbinden können.

Es gibt den Vorteil der Verwendung der gleichen Sensoren, dass Sie nicht 6 Datenblatt lesen müssen, um Ihren Code zu schreiben. Sie müssen ein Datenblatt studieren und den Code auf einfache Weise schreiben. Wenn alle Sensoren gleich sind, erhalten Sie bessere Vergleichsergebnisse.