Sensori multipli di temperatura con un Raspberry Pi

Ho visto molti esempi per l'utilizzo di un sensore di temperatura con il Raspberry Pi, tuttavia, come posso multiplexare i sensori di temperatura 5-6 su un Raspberry Pi? Voglio leggere la temperatura da più fonti contemporaneamente.

Posso semplicemente assegnare i pin GPIO sul Raspberry Pi per leggere da ciascun sensore, essenzialmente replicando la stessa configurazione per un sensore, o ho bisogno di un qualche tipo di multiplexor che tutti i sensori si collegherebbero poi a loro volta che manderebbero i dati in parallelo al Raspberry Pi?

Dato che il tuo sensore è un DS18B20, che è un circuito a 1 filo e che 1 filo è un protocollo che può eseguire indirizzi multipli sullo stesso bus e che il modulo del kernel di temperatura a 1 filo può leggere fino a 10 sensori di temperatura sullo stesso autobus. (controllare la riga 49 del codice sorgente del driver ).

Se colleghi solo 10 dei tuoi sensori agli stessi 3 pin (3v3, GND e il pin IO a 1 filo - che è il pin numero 4 sul connettore (questo è codificato nel driver!) E leggerai le loro uscite da / sys / bus / w1 / devices / 28 * / w1_slave dove il 28 * è il singolo indirizzo univoco a 1 filo. Controlla l' eccellente tutorial di adafruit . Non dimenticare la resistenza 4K7 che tira su il pin dati (numero 4 - SOLO UNO!) , poiché il pull up interno del Pi ti dà circa 50K, e questo è troppo per il sensore, quindi avrai bisogno di questo componente aggiuntivo.

Dovresti solo assicurarti di non provare a usare il potere parassitario. Se colleghi i 3 pin di tutti i dispositivi, dovresti andare bene.

Per riferimento, ecco un breve frammento di Python per eseguire il bitbang del GPIO a 1 filo e restituire la lettura della temperatura per il primo sensore. Dovrebbe essere abbastanza semplice da modificare per restituire le temperature per tutti i sensori collegati come un elenco o qualcosa di simile.

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

Parlare con un bus a 1 filo può essere doloroso. Che tu stia parlando con 1 sensore o 100, dovrai pensare al tempismo. Ho scritto del codice per il DS18B20 qualche anno fa, ma è in Assembly. Se è di qualche utilità, qui:

;***************************************************************
;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

Se interessati, ecco una guida che ho scritto per l'utilizzo di un sensore di temperatura DS18B20 (che come detto sopra può essere concatenato con quanti desideri utilizzare lo stesso pin GPIO sul Pi) con un Raspberry Pi e un codice Pyhton che lo pubblica su un Servizio RESTful che aggrega e visualizza le temperature in grafici e diagrammi su un sito web. Tutto il codice pubblico sull'account GitHub specificato. http://macgyverdev.blogspot.se/2014/01/weather-station-using-raspberry-pi.html

Che tipo di sensore di temperatura stai usando? Se hai qualcosa come un DS18B20, puoi concatenare fino a 18446744073709551615 sensori, se ne avessi così tanti.

Rispondere:

come posso multiplexare i sensori di temperatura 5-6 su un Raspberry Pi?

Ci sono moduli aggiuntivi che puoi avere che hanno diversi bus per connettersi al pi.
Questo video confronta le loro velocità: https://www.youtube.com/watch?v=YbWidNBycls Finisce per usare un kernel ricompilato per ottenere più GPIO comunicando con più sensori. Non ha pubblicato i suoi risultati su come l'ha ottenuto. Ma è possibile multiplexarlo invece di usare solo un pin.

Aggiornare. Ha pubblicato ora. Ha collegato 81 sensori a 9 GPIO separati ed è stato in grado di raggiungere tutte le temperature in meno di 3 secondi: https://www.youtube.com/watch?v=JW9wzbp35w8

il modo ideale per leggere più sensori è usare i sensori I2C.

questo è l'unico modo in cui puoi collegare più sensori insieme o puoi usare sensori analogici ma essi impiegheranno molti pin analogici ma i2c utilizzerà solo 2 linee. supponiamo che tu stia utilizzando Pi2 / 3, quindi ti suggerirò di ottenere un cappello Pi Lampone con porta I2C in modo da poter connettere tutti i tuoi dispositivi i2c con Pi in pochi secondi e assicurarti che il tuo hardware sia corretto.

ora hai il Pi con un capitolo I2C lasciati spostare sulla parte del sensore. TI, AD, NXP, freescale e molte altre aziende realizzano un sensore di temperatura con I2C ma si desidera collegare più di un sensore, quindi ci sono due opzioni.

1. ottenere 6 diversi sensori I2C diversi con diverso indirizzo I2C, se si hanno due sensori con lo stesso indirizzo non funzionerà.

2. puoi ottenere sensori con la riga dell'indirizzo e semplicemente cambiare l'indirizzo e puoi collegarli con Pi senza alcun conflitto di indirizzo. suggerirò di usare questo sensore TMP 100, preferisco questo perché ha 2 linee di indirizzo con supporto di linea di indirizzi mobile in modo da poter collegare 6 sensori con una linea i2c.

ci sono dei vantaggi nell'utilizzare gli stessi sensori: non è necessario leggere 6 schede tecniche per scrivere il codice, è necessario studiare una scheda tecnica e scrivere il codice in modo semplice. se tutti i tuoi sensori sono uguali, avrai risultati migliori da confrontare.