¿Cómo medir la temperatura?

¿Qué puedo conectar al RPi para medir la temperatura? Creo que los dispositivos conectados a I²C o SPI tendrían más sentido.

Aquí hay una pregunta sobre DHT-22 y otros dispositivos de 1 cable . Pero en esta etapa parece que 1-wire es difícil en el RPi debido a los tiempos críticos

Aquí se explica cómo conectar un MCP9804 .

Puedes usarlo así:

root@raspberrypi:~# modprobe i2c-dev
root@raspberrypi:~# modprobe i2c-bcm2708 
root@raspberrypi:~# i2cdetect -y 0
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 1f 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --                         
root@raspberrypi:~# i2cget -y 0 0x1f 0x5 w
0x67c1

Convertir 0x67c1 a una temperatura es un poco complicado. El MSB es 0xc1 y el LSB es 0x67

Los primeros 4 bits del MSB se caen y esto deja la temperatura en 16 grados

(0xc1&0xf)*16+0x67/16.0 = 22.4375 degrees 

Ejemplo de Python
Además de cargar los módulos i2c anteriores, deberá instalar el paquete python-smbus. Puede reducir el autocalentamiento apagando el MCP9804 entre lecturas.

#!/usr/bin/env python
import time
from smbus import SMBus

class MCP9804(object):
    def __init__(self, bus, addr):
        self.bus = bus
        self.addr = addr

    def wakeup(self):
        self.bus.write_word_data(self.addr, 1, 0x0000)

    def shutdown(self):
        self.bus.write_word_data(self.addr, 1, 0x0001)

    def get_temperature(self, shutdown=False):
        if shutdown:
            self.wakeup()
            time.sleep(0.26) # Wait for conversion

        msb, lsb =  self.bus.read_i2c_block_data(self.addr, 5, 2)

        if shutdown:
            self.shutdown()

        tcrit = msb>>7&1
        tupper = msb>>6&1
        tlower = msb>>5&1

        temperature = (msb&0xf)*16+lsb/16.0
        if msb>>4&1:
            temperature = 256 - temperature
        return temperature



def main():
    sensor = MCP9804(SMBus(0), 0x1f)
    while True:
        print sensor.get_temperature()
        time.sleep(1)


if __name__ == "__main__":
    main()

Puede usar el puerto serie integrado Raspberry Pi y conectarlo a un termómetro digital IC (por ejemplo, DS1620 )

Puede encontrar la interfaz de puerto serie de Raspberry Pi aquí

• P1 (IZQUIERDA INFERIOR) - 3.3V
• P6 - GND
• P8 GPIO14 - TX
• P10 GPIO15 - RX

Importante : recuerde que el RPi UART funciona a TTL 3.3V: tenga cuidado de no usar Uart de alto voltaje de 5v / 12volt directamente al RPi. ¡Causará daños!

He intentado dos enfoques para la detección de temperatura. Para I2C, utilicé un módulo TMP102 que es similar a lo que describe gnibbler. Aquí está mi publicación sobre eso:

Para 1 cable, Adafruit lanzó recientemente su propia imagen, y contiene soporte de 1 cable. Pude leer un sensor de temperatura de 1 cable DS18B20 con él. Más detalles en esta publicación :

Finalmente, otro enfoque es usar un sensor de temperatura analógico y un ADC externo. Adafruit tiene un buen tutorial sobre esto.

Un termómetro USB "HID TEMPer" simple y barato también funciona, y es mucho más fácil de conectar para aquellos que aún no están jugando con UART o GPIO, como yo.

Mi RPi proporciona suficiente potencia para conducirlo directamente desde el puerto USB sin un concentrador.

Para configurar esto con Raspbian Wheezy, seguí estas instrucciones que fueron escritas para Ubuntu (descargo de responsabilidad: el enlace es para una publicación en mi propio blog). Para la Raspberry Pi, solo tuve que hacer un pequeño ajuste para instalar LIBUSB_LIBDIRal instalar el Device::USBmódulo perl para que pudiera encontrarlo libusben la ubicación del brazo no estándar. Las instrucciones completas siguen.

Para obtener una lectura simple sin ninguna de las cosas munin , instale las dependencias de la siguiente manera (como root):

apt-get install libusb-dev
export LIBUSB_LIBDIR=/usr/lib/arm-linux-gnueabihf
cpan Inline::MakeMaker
cpan Device::USB::PCSensor::HidTEMPer

Crear readtemp.pl:

#!/usr/bin/perl
use strict;
use Device::USB::PCSensor::HidTEMPer;

my $pcsensor = Device::USB::PCSensor::HidTEMPer->new();
my @devices = $pcsensor->list_devices();
foreach my $device (@devices) {
    print $device->internal()->celsius()."\n" if defined $device->internal();
}

Y ejecutar eso como root para ver el resultado. En mi caso, hace un poco de frío en el garaje esta noche:

day@pi:~$ sudo ./readtemp.pl 
16.5

El que estoy usando actualmente es el DS18B20 .

Primero abra el Pi y escriba:

sudo leafpad /etc/apt/sources.list.d/raspi.list

Luego agrega la palabra untesteddespués main.

Luego escriba:

sudo apt-get update
sudo apt-get upgrade

En mi caso, tomó mucho tiempo, aunque depende de la velocidad de su wifi / ethernet. Después de eso, reinicia:

sudo reboot now

Conecte el cable blanco a GPIO4, el cable rojo a 3V3 y el negro a GND. También conecta una resistencia de 4.7K entre los cables blanco y rojo.

Puedes leerlo haciendo los siguientes comandos:

sudo modprobe w1-gpio
sudo modprobe w1-therm
cd /sys/bus/w1/devices/
ls

Luego debe enumerar el número de serie del sensor de temperatura, seguido de w1_bus_master1

Entonces vete:

cd serial-number-here
cat w1_slave

Y luego debe mostrar 2 líneas de código, donde los 5 dígitos al final de la segunda línea son la temperatura.

Esto utiliza algo llamado "Protocolo de sensor de temperatura de un solo cable de Dallas", o algo así.

Actualmente estoy leyendo este libro y me gusta. En esa ruta, mi visión es que tendrías un sensor de temperatura, un arduino y una radio xbee pegados. Ese es su sensor remoto que podría estar en cualquier lugar siempre que esté dentro del alcance de la estación local. Luego, para la estación de origen, tenga una frambuesa y otra xbee. Supongo que podría ser más fácil también tener la estación de origen xbee en un arduino, y luego hacer que el arduino y el rasberry se comuniquen entre sí. Con eso, podría tener múltiples sensores remotos y diferentes tipos de sensores.