Múltiples sensores de temperatura con una Raspberry Pi

19

He visto muchos ejemplos para usar un sensor de temperatura con la Raspberry Pi, sin embargo, ¿cómo puedo multiplexar 5-6 sensores de temperatura a una Raspberry Pi? Quiero leer la temperatura de varias fuentes simultáneamente.

¿Puedo simplemente asignar los pines GPIO en la Raspberry Pi para leer de cada sensor, esencialmente replicando la misma configuración para un sensor, o necesito algún tipo de multiplexor en el que todos los sensores se enchufarían y luego enviarían datos en paralelo? a la Raspberry Pi?

gpio  sensor  temperature 
— jc303
fuente
1
De la hoja de datos : "Cada DS18B20 tiene un código de serie único de 64 bits, que permite que múltiples DS18B20 funcionen en el mismo bus de 1 cable". Intente leer la hoja de datos (no se preocupe si no comprende todo).
— Gerben

Respuestas:

18

Dado que su sensor es un DS18B20, y es un circuito de 1 cable y que 1 cable es un protocolo que puede realizar múltiples direcciones en ese mismo bus y que el módulo del núcleo de temperatura de 1 cable puede leer hasta 10 sensores de temperatura en el mismo bus (verifique la línea 49 del código fuente del controlador ).

Si solo conecta 10 de sus sensores a los mismos 3 pines (3v3, GND y el pin IO de 1 cable, que es el pin número 4 en el conector (¡esto está codificado en el controlador!) Y leerá sus salidas desde / sys / bus / w1 / devices / 28 * / w1_slave donde el 28 * es la dirección individual única de 1 cable. Consulte el excelente tutorial de adafruit . No olvide la resistencia 4K7 que tira del pin de datos (número 4 - ¡SOLO UNO!) , ya que la extracción interna del Pi le da aproximadamente 50K, y eso es demasiado para el sensor, por lo que necesitará este componente adicional.

Solo debes asegurarte de no estar tratando de usar el poder parasitario. Si conecta los 3 pines de todos los dispositivos, debería estar bien.

— Marco Poli
fuente
Hola, actualmente estoy en el proceso de diseño de hacer un registrador de temperatura de 10 sensores con algunos DS18B20, tengo más o menos lo que estás diciendo anteriormente, excepto el bit de potencia parasitaria: You should just make sure you are not trying to use parasitic power.¿Qué quieres decir con esto? ¿Necesito usar una fuente de alimentación externa en lugar de los 3.3V del pin1 en el GPIO del Pi? ¿O es el poder parasitario si solo uso GND + Data y no el 3V3? - se negó a hacer un enlace activo a su nombre de usuario :-(
— Jim
2
@Jim Parasitic power es una característica del DS18B20 por el cual conecta solo los pines GND e IO al bus, no VCC. Marco Poli dice que no debes ejecutarlo en este modo, sino que conecta los 3 cables del DS18B20 a la Pi. No necesitará una fuente de alimentación externa.
— NoChecksum
Hola, con respecto a tu comentario, this is hardcoded in the driver¿eso significa que conectar sensores de temperatura a un pin GPIO diferente (o múltiples pines GPIO) no funcionará?
— Bprodz
4

Como referencia, aquí hay un pequeño fragmento de Python para hacer un bitbang en el GPIO de 1 cable y devolver la lectura de temperatura para el primer sensor. Debe ser lo suficientemente sencillo de modificar para devolver las temperaturas de todos los sensores conectados como una lista o algo similar.

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
— ropable
fuente
necesita tiempo de importación del subproceso de importación para ejecutarse
— Paul Anderson
2

Hablar por un autobús de 1 cable puede ser doloroso. Ya sea que esté hablando con 1 sensor o 100, deberá pensar en el tiempo. Escribí un código para el DS18B20 hace unos años, pero está en la Asamblea. Si es de alguna utilidad, aquí:

;***************************************************************
;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
— Dr P Bacon
fuente
3
El Raspberry pi ya tiene un módulo de núcleo para 1 cable y otro específicamente para sensores de temperatura de 1 cable (que incluye DS18B20). Simplemente cargue los módulos y la temperatura se lee desde un archivo, con un comando de lectura de archivo reagular. No necesita implementar manualmente el protocolo, si elige usar los módulos listos.
— Marco Poli
2

Si está interesado, aquí hay una guía que escribí para usar un sensor de temperatura DS18B20 (que como se indicó anteriormente se puede encadenar con tantos como desee usando el mismo pin GPIO en el Pi) con un Raspberry Pi y un código Pyhton que lo publica en un Servicio RESTful que agrega y muestra las temperaturas en gráficos y diagramas en un sitio web. Todo el código público en la cuenta de GitHub especificada. http://macgyverdev.blogspot.se/2014/01/weather-station-using-raspberry-pi.html

— Johan Norén
fuente
1

¿Qué tipo de sensor de temperatura estás usando? Si tiene algo como un DS18B20, puede encadenar hasta 18446744073709551615 sensores, si tuviera tantos.

— TheDoctor
fuente
El sensor es del tipo DS18B20, sin embargo, ¿puede explicar qué significa encadenar y, si es posible, señalar una fuente para la implementación de dicha técnica? ¿Cómo se diferenciaría entre las entradas del sensor si estuvieran encadenadas? Necesito adquirir y la salida del sensor gráfico de temperatura 1, sensor de temperatura 2 .... sensor de temperatura n.
— jc303
2
@JadCooper cada sensor ds18b20 tiene un número de serie de 16 bits. Cuando se dirige a un sensor con eso, devuelve datos solo de ese sensor. Ver (este tutorial) [ learn.adafruit.com/… para usarlos en la pi
— TheDoctor
0

Contestar:

¿Cómo puedo multiplexar 5-6 sensores de temperatura a una Raspberry Pi?

Hay módulos adicionales que puede obtener que tienen varios buses para conectarse al pi.
Este video compara sus velocidades: https://www.youtube.com/watch?v=YbWidNBycls Él termina usando un kernel recompilado para lograr que GPIO se comunique con múltiples sensores. No ha publicado sus resultados sobre cómo lo consiguió. Pero es posible multiplexarlo en lugar de usar solo un pin.

Actualizar. Él ha publicado ahora. Conectó 81 sensores a 9 GPIO separados y pudo obtener todas las temperaturas en menos de 3 segundos: https://www.youtube.com/watch?v=JW9wzbp35w8

— raspi-ninja
fuente
0

La forma ideal de leer sensores múltiples es usar sensores I2C.

esta es la única forma en que puede encadenar múltiples sensores juntos o puede usar sensores analógicos, pero tomarán muchos pines analógicos, pero i2c usará solo 2 líneas. Digamos que está usando Pi2 / 3, luego le sugiero que obtenga un sombrero de frambuesa Pi que tenga un puerto I2C para que pueda conectar todos sus dispositivos i2c con Pi en cuestión de segundos y se asegurará de que su hardware sea correcto.

ahora tienes el Pi con un adpter I2C, deja que se mueva en la parte del sensor. TI, AD, NXP, freescale y muchas otras compañías fabrican sensores de temperatura con I2C pero desea conectar más de un sensor, por lo que hay dos opciones.

  1. obtenga 6 sensores I2C diferentes con diferentes direcciones I2C, si tiene dos sensores con la misma dirección no funcionará.

  2. puede obtener sensores con línea de dirección y simplemente cambiar la dirección y puede conectarlos con Pi sin ningún conflicto de direcciones. sugeriré usar este sensor TMP 100, prefiero este porque tiene 2 líneas de dirección con soporte de línea de dirección flotante para que pueda conectar 6 sensores con una línea i2c.

La ventaja de usar los mismos sensores es que no tiene que leer 6 hojas de datos para escribir su código, tendrá que estudiar una hoja de datos y escribir el código de manera fácil. Si todos sus sensores son iguales, tendrá mejores resultados para comparar.

— bruce
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.