Termómetro para barbacoa, ahumador, horno… con Raspberry Pi

by tuxotron - on abr 21st 2015 - No Comments


20150420_215837.jpg

Hace un par de fin de semanas que quedé con un amigo para ahumar unas costillas y solomillos. El proceso de ahumar, para mi sorpresa es más laborioso y delicado de lo que pensaba. Una de las claves de dicho proceso es la temperatura.

El ahumador de este amigo mío, por supuesto tenía un termómetro, pero dejó de funcionar aquel día, así que tuvimos que estimar la potencia del mismo, y así salíó la carne :p

Una de las conversaciones que tuvimos a lo largo del día fue la de crear un termómetro para el ahumador y que además pudieramos comprobar la temperatura de forma remota. Y de ahí al proyecto de fin de semana y el motivo de esta entrada.

Para montar todo este tinglado, necesitaba un Raspberry Pi con todos sus avíos (tarjeta de memoria, fuente de alimentación y adaptador inalámbrico), pero necesitaba el/los componente/s esenciales, algún sensor que sea capaz de soportar altas temperaturas y que puede conectar al RPi.
Después de buscar un rato y echar un vistazo a un proyecto llamado HeaterMeter, me decidí por una opción más sencilla para mi. Me hice con un par térmico (thermocouple), éste en concreto y un circuito amplificador (MAX31855) para hacer de interfaz con el RPi.

componentes

Después de soldar la componentes del circuito y conectar el par térmico al mismo, llega el momento de conectarlo al RPi.

El amplificador usa SPI para comunicarse con nuestro RPi. El RPi dispone de 3 SPIs, pero sólo 1 está expuesto a la cabeza de pines (GPIO).

Tenemos 2 formas de comunicarnos con el interfaz SPI, por hardware o software. La librería que usaremos para leer el sensor, nos permite usar directamente el SPI del RPi, o emularlo por software. La ventaja principal del uso de SPI por hardware sobre software, es que se más rápido a la hora de comunicarnos con el sensor, que en nuestro caso es irrelevante, ya que no necesitamos leer la temperatura a intervalos muy cortos. Otra ventaja que tenemos al usar el SPI por hardware, es que dejamos libres los pines de propósito general, en caso que conectemos más sensores.

Nota: he probado los dos métodos y funcionan exactamente igual y la diferencia de velocidad es inapreciable, pero me decanté por método hardware por la segunda razón antes mencionada.

Antes de ponernos a cablear, suponemos que tenemos instalado un sistema Raspbian, actualizado y con conexión a internet. Si te decantas por el método hardware además tienes que activar SPI en tu sistema, ya que por defecto viene bloqueado. Esto lo puedes hacer desde la utilidad de configuración raspi-config:


raspi-config1.png


raspi-config2.png

O lo puedes activarlo directamente actualizando el fichero /etc/modprobe.d/raspi-blacklist.conf:

#blacklist spi-bcm2708 (debes borrar el #)

blacklist spi-bcm2708

Lo actives de una forma u otra (recomendado raspi-config), debes reiniciar el RPi.

Ahora ya tenemos listo nuestro sistema. Lo siguiente será cablear el amplificador a nuestro RPi. Para ello, como mencioné antes, usaré el método por hardware:


temperature_pi-hardwarespi-max31855_bb.png

https://learn.adafruit.com/max31855-thermocouple-python-library/hardware

Conectamos:
RPi 3.3V a amplificador Vin.
RPi GND a amplificador GND.
RPi MISO a amplificador DO.
RPi CS0 a amplificador CS.
RPi SCLK a amplificador CLK.


20150420_210650.jpg

Seguidamente conectamos el hilo térmico al amplificador. Aunque se supone que los dos hilos del par térmico son de colores, en mi caso los terminales son de color plata, así que lo conecté y me funcionó a la primera. Si lo conectes y no te da los datos correctos, pues dale la vuelta :).


20150420_210726.jpg

Una vez tenemos conectado los cables, vamos a la parte del software. Para este proyecto yo usé unas librerías escrita en python de Adafruit.

Los siguientes pasos los puedes seguir desde el propio RPi o conectándote por ssh.

Primero instalamos varios paquetes que necesitaremos:

sudo apt-get install build-essential python-dev python-pip python-smbus git
sudo pip install RPi.GPIO

Ahora instalamos la librería de Adafruit:

cd ~
git clone https://github.com/adafruit/Adafruit_Python_MAX31855.git
cd Adafruit_Python_MAX31855
sudo python setup.py install

Dentro de Adafruit_Python_MAX31855/examples, hay un fichero llamado simpletest.py. Si has conectado el amplificador usando los pines de propósito general (método software), puedes ejecutar dicho programa. Si, por el contrario has usado los pines dedicado para SPI (método hardware), tienes que editar dicho fichero y comentar y decomentar las varias líneas de código, de forma que quede así:

# Raspberry Pi software SPI configuration.
#CLK = 25
#CS = 24
#DO = 18
#sensor = MAX31855.MAX31855(CLK, CS, DO)

# Raspberry Pi hardware SPI configuration.
SPI_PORT = 0
SPI_DEVICE = 0
sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))

Ahora podemos ejecutar (con sudo) simpletest.py. Si la salida tiene esta pinta:

pi@raspberrypi ~/Adafruit_Python_MAX31855/examples $ sudo python simpletest.py
Press Ctrl-C to quit.
Thermocouple Temperature: 0.000*C / 32.000*F
Internal Temperature: 0.000*C / 32.000*F
Thermocouple Temperature: 0.000*C / 32.000*F
Internal Temperature: 0.000*C / 32.000*F
Thermocouple Temperature: 0.000*C / 32.000*F
Internal Temperature: 0.000*C / 32.000*F
Thermocouple Temperature: 0.000*C / 32.000*F
Internal Temperature: 0.000*C / 32.000*F

Es que algo está mal. Revisa el cableado y asegúrate de usar el código correcto.
Una ejecución correcta sería algo como:

pi@raspberrypi ~/Adafruit_Python_MAX31855/examples $ sudo python simpletest.py
Press Ctrl-C to quit.
Thermocouple Temperature: 27.750*C / 81.950*F
Internal Temperature: 35.625*C / 96.125*F
Thermocouple Temperature: 27.750*C / 81.950*F
Internal Temperature: 35.688*C / 96.237*F
Thermocouple Temperature: 27.750*C / 81.950*F
Internal Temperature: 35.688*C / 96.237*F
Thermocouple Temperature: 27.750*C / 81.950*F
Internal Temperature: 35.688*C / 96.237*F

Cómo puedes ver, tenemos 2 temperaturas distintas la del par térmico (thermocouple) y la interna. Ésta última viene de un sensor de temperatura que tiene el amplificador. De esta forma podemos saber dentro de el ahumador, barbacoa, etc y la exterior.

Ahora que ya tenemos todo funcionando, lo siguiente que hice fue crear un servicio REST. Para ello usé la librería web.py.

Para instalarla usé easy_install:

sudo easy_install web.py

Y escribí un pequeño script, donde lo más importante:

....
urls = (
'/', 'index',
'/temperature', 'temperature'
)
app = web.application(urls, globals())
class index:
def GET(self):
try:
f = open('/home/pi/index.html', 'r')
return f.read()
except:
return 'Not found'
class temperature:
def GET(self):
external = sensor.readTempC()
internal = sensor.readInternalC()
output = '"external": {0:0.3F}, \r "internal": {1:0.3F}'.format(external, internal)
web.header('Content-Type', 'application/json')
return '{\r' + output + '\r}'
....

El servicio REST responde a la URL /temperature y nos devuelve el resultado en formato JSON con las temperaturas interior y exterior en grados centígrados. Con esto ya puedes crear lo que te apetezca, desde un simple llamada desde la línea de comandos, una aplicación móvil, etc.
Yo por comodidad creé un fichero index.html (como podéis ver en el código anterior) que responde a la URL / (raíz) y llama al servicio REST cada 5 segundos y nos muestra la temperatura.

El código completo lo tenéis en este repositorio.

Para terminar os dejo un pequeño vídeo con el par térmico dentro del horno de casa. Lo programé a 350 grados fahrenheit y durante el vídeo, estaba en modo calentamiento, todavía no había alcanzado los 350 grados, y vemos desde el portátil como la temperatura va subiendo.

Todavía no he hecho una prueba real con el ahumador, pero tengo buenas vibraciones :p

Happy hacking!

Comparte el post:
  • Meneame
  • Bitacoras.com
  • BarraPunto
  • RSS
  • email
  • PDF
  • Facebook
  • Twitter
  • Digg
  • Google Bookmarks
  • Wikio
  • Reddit
  • Technorati

Entradas relacionadas:

Asignando IP estática al adaptador inalámbrico de tu Raspberry Pi

by tuxotron - on abr 20th 2015 - 1 Comment


rpi_static_ip.png

Cada vez que juego con un Raspberry Pi, el resultado final suele ser conectar algún sensor y exponer los datos del mismo a través de algún servicio REST.
Esto implica que el RPi es instalado en mi red en modo servidor, al cual le mando peticiones y recibo respuestas.

Por defecto, cuando instalas el sistema operativo (Raspbian en mi caso), la configuración del adaptador inalámbrico es trivial, pero se configura en modo DHCP, es decir, el router asigna la IP de forma dinámica. Normalmente, te asigna la misma IP siempre, pero no se garantiza.

Nuestro objetivo es garantizar que el RPi siempre tenga la misma IP.

La configuración de IP estática del adaptador inalámbrico no es tan trivial como parece. Por ejemplo, cuando queremos asignar un IP estática al adaptador de red ethernet (eth0 por defecto), la solución es simple:

Nuestro fichero /etc/network/interfaces inicialmente tiene el siguiente contenido (suponiendo que tengas un adaptador de red inalámbrico – wlan0)

auto lo

iface lo inet loopback
iface eth0 inet dhcp

allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

Para asignarle una IP estática a nuestro adaptador de red eth0, todo lo que tenemos que hacer es cambiar la línea:

iface eth0 inet dhcp

por:

iface eth0 inet static

Y añadir:

address 192.168.1.50
network 255.255.255.0
gateway 192.168.1.1

Los valores dependeran de la configuración de tu red.

Con eso nos bastaría. Para configurar el adaptador inalámbrico wlan0, uno podría pensar, pues hago lo mismo, cambio la línea:

iface wlan0 inet manual

Y añado los valores, pero eso no funciona, al menos a mi no me funciona. Lo que tenemos que hacer es crear una interfaz nueva, llamémosla home :

iface home inet static

Y justo debajo los valores:

address 192.168.1.35
netmask 255.255.255.0
gateway 192.168.1.1

De nuevo, estos valores podrían ser distintos en to LAN.

Además de eso, también tenemos que modificar el fichero /etc/wpa_supplicant/wpa_supplicant.conf y definir la variable id_str y asignarle el valor de la nueva interfaz que definimos anteriormente, en nuestro caso home. Nuestro fichero /etc/wpa_supplicant/wpa_supplicant.conf tendría algo parecido a esto:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
ssid=”******”
psk=”******”
proto=RSN
key_mgmt=WPA-PSK
pairwise=TKIP
auth_alg=OPEN
id_str=”home”
}

Los valores de ssid y psk mostrarán el nombre de tu red inalámbrica y la contraseña respectivamente.

Una vez hechos estos cambios, puedes activarlos:

sudo service networking restart

O aún mejor, reinicia tu RPi para asegurarte de que la IP es asignada correctamente en el arranque.

Comparte el post:
  • Meneame
  • Bitacoras.com
  • BarraPunto
  • RSS
  • email
  • PDF
  • Facebook
  • Twitter
  • Digg
  • Google Bookmarks
  • Wikio
  • Reddit
  • Technorati

Entradas relacionadas:

Domingo por la mañana … This Will Destroy You, “New Topia”

by cybercaronte - on abr 19th 2015 - No Comments

This Will Destroy You

Esa batería del final sólo es comparable a Mogwai y su magnífico “Mogwai fear Satan” …

Comparte el post:
  • Meneame
  • Bitacoras.com
  • BarraPunto
  • RSS
  • email
  • PDF
  • Facebook
  • Twitter
  • Digg
  • Google Bookmarks
  • Wikio
  • Reddit
  • Technorati

Entradas relacionadas:

Técnicas moderna de explotación de Objective-C

by tuxotron - on abr 17th 2015 - No Comments


phrack-logo.jpg

La ezine sobre hacking/seguridad por excelencia, Phrack, acaba de publicar un nuevo documento titulado Modern Objective-C Exploitation Techniques.

El documento trata sobre la explotación de aplicaciones escritas en Objective-C basada en la corrupción de la memoria. El autor de dicho trabajo, ya publicó en su día otro artículo en el número 66 de Phrack sobre cómo entender y abusar Objective-C en tiempo de ejecución The Objective-C Runtime: Understanding and Abusing, cuya lectura es recomendada previo a ésta.

El índice de esta nueva publicación es el siguiente:

  • Introduction
  • Dangling Objective-C Method Calls
  • 32-bit dangling objc_msgSend()
    • 32-bit Shared Region
    • Uncommon 32-bit Libraries
  • 64-bit dangling objc_msgSend()
    • 64-bit Shared Region
    • Uncommon 64-bit Libraries
  • Single Gadget Exploitation Strategies
    • Return SEL Gadget
    • Self Modifying ROP
    • Arbitrary Write Gadget
  • Tagged Pointers
    • Tagged NSAtom
    • Tagged NSString
    • Tagged NSNumber
    • Additional Tagged Types
  • Blocks
  • Sample Block Code
  • Exploitation
  • Future Research — Non Pointer ISA
  • Conclusion
  • References
  • Appendix – Source Code
Comparte el post:
  • Meneame
  • Bitacoras.com
  • BarraPunto
  • RSS
  • email
  • PDF
  • Facebook
  • Twitter
  • Digg
  • Google Bookmarks
  • Wikio
  • Reddit
  • Technorati

Entradas relacionadas: