Vários sensores de temperatura com um Raspberry Pi

19

Eu já vi muitos exemplos de uso de um sensor de temperatura com o Raspberry Pi; no entanto, como posso multiplexar sensores de temperatura 5-6 em um Raspberry Pi? Eu quero ler a temperatura de várias fontes simultaneamente.

Posso simplesmente atribuir os pinos GPIO no Raspberry Pi para ler cada sensor, replicando essencialmente a mesma configuração para um sensor, ou preciso de algum tipo de multiplexador ao qual todos os sensores se conectariam para enviar dados em paralelo? para o Raspberry Pi?

gpio  sensor  temperature 
— jc303
fonte
1
Na folha de dados : "Cada DS18B20 possui um código serial exclusivo de 64 bits, que permite que vários DS18B20s funcionem no mesmo barramento de 1 fio". Tente ler a folha de dados (não se preocupe se você não entender tudo).
— Gerben 6/08/2013

Respostas:

18

Dado que o seu sensor é um DS18B20 e é um circuito de 1 fio e esse fio é um protocolo que pode endereçar vários endereços no mesmo barramento e que o módulo do núcleo de temperatura de 1 fio pode ler até 10 sensores de temperatura no mesmo ônibus. (verifique a linha 49 do código fonte do driver ).

Se você conectar apenas 10 dos seus sensores aos mesmos 3 pinos (3v3, GND e o pino IO de 1 fio - que é o número 4 no conector (este é codificado no driver!) E você lerá as saídas em / sys / bus / w1 / devices / 28 * / w1_slave, onde o 28 * é o endereço de um fio único individual. Verifique o excelente tutorial do adafruit . Não esqueça o resistor 4K7 que puxa o pino de dados (número 4 - SOMENTE UM!) , como o pull-up interno do Pi fornece aproximadamente 50K e isso é demais para o sensor, você precisará desse componente extra.

Você só deve ter certeza de que não está tentando usar o poder parasitário. Se você conectar os 3 pinos de todos os dispositivos, tudo bem.

— Marco Poli
fonte
Olá, atualmente estou no processo de criação de um registrador de temperatura de 10 sensores com alguns DS18B20s. Entendi o que você está dizendo acima, exceto pelo bit de energia parasita: You should just make sure you are not trying to use parasitic power.O que você quer dizer com isso? Preciso usar uma fonte de alimentação externa em vez dos 3,3V do pino1 no GPIO do Pi? Ou é poder parasitário se eu usar apenas dados GND + e não o 3V3? - recusou-se a vincular hot-link ao seu nome de usuário :-(
— Jim
2
@ Jim A energia parasita é um recurso do DS18B20, no qual você conecta apenas os pinos GND e IO ao barramento, não o VCC. Marco Poli está dizendo que você não deve executá-lo neste modo, em vez disso, conecta todos os 3 fios dos DS18B20s ao Pi. Você não precisará de uma fonte de alimentação externa.
— NoChecksum
Olá, com relação ao seu comentário, this is hardcoded in the driverisso significa que a conexão de sensores de temperatura a um pino GPIO diferente (ou vários pinos GPIO) não funcionará?
— Bprodz
4

Para referência, aqui está um pequeno trecho do Python para bitbang do GPIO de 1 fio e retornar a leitura de temperatura para o primeiro sensor. Deve ser simples o suficiente modificar para retornar os temps para todos os sensores conectados como uma lista ou algo semelhante.

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
— cordável
fonte
necessidades importar tempo de importação subprocesso para executar
— Paul Anderson
2

Conversar sobre um barramento de 1 fio pode ser doloroso. Esteja você falando com 1 sensor ou 100, precisará pensar no tempo. Eu escrevi algum código para o DS18B20 há alguns anos atrás, mas está em Assembly. Se for de alguma utilidade, aqui:

;***************************************************************
;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
fonte
3
O Raspberry pi já possui um módulo de kernel para 1 fio e outro especificamente para sensores de temperatura de 1 fio (que inclui o DS18B20). Basta carregar os módulos e a temperatura é lida em um arquivo, com um comando de leitura de arquivo reagular. Você não precisa implementar manualmente o protocolo, se optar por usar os módulos prontos.
— Marco Poli
2

Se estiver interessado, aqui está um guia que escrevi para o uso de um sensor de temperatura DS18B20 (que, como mencionado acima, pode ser encadeado com quantos você desejar usando o mesmo pino GPIO no Pi) com um Raspberry Pi e algum código Pyhton que o publica em um Serviço RESTful que agrega e exibe as temperaturas em gráficos e diagramas em um site. Todo o código público na conta GitHub especificada. http://macgyverdev.blogspot.se/2014/01/weather-station-using-raspberry-pi.html

— Johan Norén
fonte
1

Que tipo de sensor de temperatura você está usando? Se você tem algo como um DS18B20, pode conectar até 18446744073709551615 sensores, se você tiver muitos.

— O médico
fonte
O sensor é do tipo DS18B20, no entanto, você pode elaborar o significado de encadeamento e, se possível, apontar para uma fonte para a implementação dessa técnica. Como se diferenciaria entre as entradas do sensor se elas fossem encadeadas? Eu preciso adquirir e a saída do sensor de temperatura gráfico 1, sensor de temperatura 2 .... sensor de temperatura n.
— Jc303
2
@JadCooper, cada sensor ds18b20 possui um número de série de 16 bits. Quando você endereça um sensor com isso, ele retorna dados somente desse sensor. Veja (este tutorial) [ learn.adafruit.com/… para usá-los no pi
— TheDoctor
0

Para responder:

como multiplexar 5-6 sensores de temperatura em um Raspberry Pi?

Existem módulos adicionais que você pode obter com vários barramentos para se conectar ao pi.
Este vídeo compara suas velocidades: https://www.youtube.com/watch?v=YbWidNBycls Ele acaba usando um kernel recompilado para obter vários GPIO se comunicando com vários sensores. Ele não publicou seus resultados sobre como conseguiu. Mas é possível multiplexá-lo em vez de usar apenas um pino.

Atualizar. Ele postou agora. Ele conectou 81 sensores a 9 GPIO separados e conseguiu obter todas as temperaturas em menos de 3 segundos: https://www.youtube.com/watch?v=JW9wzbp35w8

— raspi-ninja
fonte
0

a maneira ideal de ler vários sensores é usar sensores I2C.

Essa é a única maneira de conectar vários sensores ou usar sensores analógicos, mas eles receberão muitos pinos analógicos, mas o i2c usará apenas 2 linhas. digamos que você esteja usando o Pi2 / 3, então sugiro que você obtenha um chapéu Pi framboesa com porta I2C para que você possa conectar todos os seus dispositivos i2c com o Pi em segundos e garantirá que o seu hardware esteja correto.

agora você tem o Pi com um adaptador I2C e deixe passar a parte do sensor. TI, AD, NXP, freescale e muitas outras empresas fabricam sensores de temperatura com I2C, mas você deseja conectar mais de um sensor para que haja duas opções.

  1. obtenha 6 sensores I2C diferentes com endereço I2C diferente; se você tiver dois sensores com o mesmo endereço, ele não funcionará.

  2. você pode obter sensores com a linha de endereço e apenas alterar o endereço e conectá-los ao Pi sem nenhum conflito de endereço. Eu sugiro usar este sensor TMP 100. Prefiro este porque ele possui 2 linhas de endereço com suporte de linha de endereço flutuante para que você possa conectar 6 sensores a uma linha i2c.

a vantagem de usar os mesmos sensores é que você não precisa ler 6 folhas de dados para escrever seu código, será necessário estudar uma folha de dados e escrever o código da maneira mais fácil. se todos os seus sensores forem iguais, você terá melhores resultados para comparar.

— Bruce
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.