Beberapa sensor suhu dengan Raspberry Pi

Saya telah melihat banyak contoh untuk menggunakan satu sensor suhu dengan Raspberry Pi, namun, bagaimana saya bisa mengalikan sensor suhu 5-6 ke Raspberry Pi? Saya ingin membaca suhu dari beberapa sumber secara bersamaan.

Dapatkah saya cukup menetapkan pin GPIO pada Raspberry Pi untuk membaca dari masing-masing sensor, pada dasarnya mereplikasi konfigurasi yang sama untuk satu sensor, atau apakah saya memerlukan semacam multiplexor yang akan dipasang oleh semua sensor pada gilirannya yang akan mengirim data secara paralel ke Raspberry Pi?

Mengingat bahwa sensor Anda adalah DS18B20, dan ini adalah sirkuit 1-kawat dan bahwa 1-kawat adalah protokol yang dapat melakukan multiple adressing pada bus yang sama dan bahwa modul kernel suhu 1-kawat dapat membaca sebanyak 10 sensor suhu di bus yang sama. (periksa baris 49 dari kode sumber driver ).

Jika Anda hanya menghubungkan 10 sensor Anda ke 3 pin yang sama (3v3, GND dan 1-pin IO pin - yang merupakan pin nomor 4 pada konektor (ini adalah hardcoded pada driver!) Dan Anda akan membaca output mereka dari / sys / bus / w1 / devices / 28 * / w1_slave di mana 28 * adalah alamat 1-kawat unik individu. Periksa tutorial luar biasa dari adafruit . Jangan lupa resistor 4K7 yang menarik pin data (nomor 4 - HANYA SATU!) , karena penarikan internal Pi memberi Anda sekitar 50K, dan itu terlalu banyak untuk sensor, sehingga Anda akan memerlukan komponen tambahan ini.

Anda hanya harus memastikan Anda tidak mencoba menggunakan kekuatan parasit. Jika Anda menghubungkan 3 pin dari semua perangkat, Anda akan baik-baik saja.

Untuk referensi, berikut adalah potongan pendek Python untuk menggigit GPIO 1-kawat dan mengembalikan pembacaan suhu untuk sensor pertama. Itu harus cukup mudah untuk memodifikasi untuk mengembalikan temp untuk semua sensor yang terhubung sebagai daftar atau sesuatu yang serupa.

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

Membicarakan bis 1-kawat bisa menyakitkan. Baik Anda berbicara dengan 1 sensor atau 100, Anda harus memikirkan waktu. Saya menulis beberapa kode untuk DS18B20 beberapa tahun yang lalu, tetapi dalam Majelis. Jika ada gunanya, di sini:

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

Jika tertarik, inilah panduan yang saya tulis untuk menggunakan sensor suhu DS18B20 (yang sebagaimana disebutkan di atas dapat dirantai dengan sebanyak yang Anda inginkan menggunakan pin GPIO yang sama pada Pi) dengan Raspberry Pi dan beberapa kode Pyhton yang mempostingnya ke Layanan tenang yang mengumpulkan dan menampilkan suhu dalam bagan dan diagram di situs web. Semua kode publik pada akun GitHub yang ditentukan. http://macgyverdev.blogspot.se/2014/01/weather-station-using-raspberry-pi.html

Apa jenis sensor suhu yang Anda gunakan? Jika Anda memiliki sesuatu seperti DS18B20 maka Anda dapat menghubungkan hingga 18446744073709551615 sensor, jika Anda memiliki banyak.

Untuk menjawab:

bagaimana cara saya mengalikan sensor suhu 5-6 ke Raspberry Pi?

Ada tambahan modul yang bisa Anda dapatkan yang memiliki beberapa bus untuk terhubung ke pi.
Video ini membandingkan kecepatan mereka: https://www.youtube.com/watch?v=YbWidNBycls Dia akhirnya menggunakan kernel yang dikompilasi ulang untuk mencapai beberapa GPIO berkomunikasi dengan beberapa sensor. Dia belum memposting hasilnya tentang bagaimana dia mendapatkannya. Tetapi dimungkinkan untuk multiplex daripada menggunakan hanya satu pin.

Memperbarui. Dia telah memposting sekarang. Dia menghubungkan 81 sensor ke 9 GPIO yang terpisah dan mampu mendapatkan semua suhu dalam waktu kurang dari 3 detik: https://www.youtube.com/watch?v=JW9wzbp35w8

cara ideal untuk membaca banyak sensor adalah menggunakan sensor I2C.

ini adalah satu-satunya cara Anda dapat menghubungkan beberapa sensor bersama-sama atau Anda dapat menggunakan sensor analog tetapi mereka akan mengambil banyak pin analog tetapi i2c hanya akan menggunakan 2 baris. katakanlah Anda menggunakan Pi2 / 3, maka saya akan menyarankan mendapatkan topi Raspberry Pi yang memiliki port I2C sehingga Anda dapat menghubungkan semua perangkat i2c Anda dengan Pi dalam hitungan detik dan itu akan memastikan perangkat keras Anda benar.

sekarang Anda memiliki Pi dengan adpter I2C, biarkan bergerak pada bagian sensor. TI, AD, NXP, freescale dan banyak perusahaan lain membuat sensor temp dengan I2C tetapi Anda ingin menghubungkan lebih dari satu sensor sehingga ada dua opsi.

1. dapatkan 6 sensor I2C berbeda dengan alamat I2C berbeda, jika Anda memiliki dua sensor dengan alamat yang sama tidak akan berfungsi.

2. Anda bisa mendapatkan sensor dengan garis alamat dan hanya mengubah alamat dan Anda dapat menghubungkannya dengan Pi tanpa konflik alamat. Saya akan menyarankan menggunakan sensor TMP 100 ini saya lebih suka yang ini karena memiliki 2 baris alamat dengan dukungan garis alamat mengambang sehingga Anda dapat menghubungkan 6 sensor dengan satu baris i2c.

ada keuntungan menggunakan sensor yang sama adalah Anda tidak perlu membaca 6 lembar data untuk menulis kode Anda, Anda perlu mempelajari satu lembar data dan menulis kodenya dengan mudah. jika semua sensor Anda sama maka Anda akan memiliki hasil yang lebih baik untuk dibandingkan.