Blog de Alexis Abarca

Al descargar raspbian viene como un archivo .img que se debe copiar a la SD usando Win32DiskImager (Windows) o dd (Linux), la imagen tiene dos particiones, una de boot tipo fat32 y la del sistema tipo ext4.

Normalmente no es necesario separar las particiones porque se usa el Raspberry de la SD, pero en instalaciones especiales como cuando la partición del sistema está en una unidad USB o en un volumen LVM se requiere separar para copiar sólo la partición del sistema fuera de la SD.

Para hacer la separación se deben ejecutar estos comandos

parted -s raspbian.img unit KiB print

El comando retorna estos datos, a partir de ellos se pueden obtener los números para hacer la separación, los que se usarán los he puesto con letras al lado

Model:  (file)
Disk /mnt/hdd30/raspbian/2017-04-10-raspbian-jessie-lite.img: 1267444kiB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start     End         Size        Type     File system  Flags
1      (A) 4096kiB   46080kiB    (B) 41984kiB    primary  fat32        lba
2      (C) 46080kiB  1267444kiB  (D) 1221364kiB  primary  ext4

Para obtener las imagenes individuales se usan estos comandos

dd if=raspbian.img of=boot.img bs=1024 skip=(A) count=(B)
dd if=raspbian.img of=system.img bs=1024 skip=(C) count=(D)

 

Las letras se deben reemplazar por los números obtenidos anteriormente, al final obtendrás los archivos boot.img y system.img.

Fuente: http://elinux.org/RPi_Resize_Flash_Partitions#Manually_extracting_partitions_from_the_image_on_Linux

Usualmente el Sistema Operativo del Raspberry Pi se ejecuta desde la tarjeta microSD (o SD en el Rpi1), pero dependiendo de la SD y con el paso del tiempo se puede ir dañando la información haciendo necesario tener que reinstalar el SO regularmente. Esto se puede evitar usando la SD sólo para el bootloader y el SO dejarlo en una partición en un pendrive o disco externo.

Estos pasos los realicé desde un Raspberry Pi booteado desde la SD.

• Crear partición LVM e inicializar con pvcreate/vgcreate (omitir si ya existe)
• Crear volumen LVM con

lvcreate -n <nombre vol> -L 10G <nombre vg>

• En la página donde obtuve la información hicieron una copia del root actual a la nueva partición, yo en lugar de eso copie la imagen del sistema raspbian original al nuevo volumen (no la imagen original, ya que incluye la partición de boot, tuve que dividirla primero)

dd if=system.img of=/dev/<nombre vg>/<nombre lv> bs=1M

• Ajustar partición para que ocupe todo el tamaño del LV

e2fsck -f /dev/<nombre vg>/<nombre lv>
resize2fs /dev/<nombre vg>/<nombre lv>

• Ahora hay que hacer chroot en el sistema nuevo para ajustar el fstab e instalar el initramfs y lvm. La línea touch ssh es opcional, es para que en el sistema nuevo se active el servicio SSH por defecto si estás haciendo estos pasos por SSH.

mkdir /mnt/root
mount /dev/<nombre vg>/<nombre lv> /mnt/root
mount -t proc /proc /mnt/root/proc
mount -o bind /dev /mnt/root/dev
mount -o bind /dev/pts /mnt/root/dev/pts
mount -t sysfs /sys /mnt/root/sys
mount -o bind /boot /mnt/root/boot
touch /mnt/root/boot/ssh
chroot /mnt/root

Ya ví cómo controlar un relé, ahora le agregaré un sensor de puerta para que cuando ésta se abra pueda ejecutar una acción, como activar un relé.

Materiales

• Raspberry Pi (sigo usando el 2, pero también debería servir el 1)
• Sensor magnético
• Cable para conectar ambas cosas, se necesitarán varios metros dependiendo de la distancia.

Conexión

Por el extremo del sensor se deben conectar los dos cables y se debe instalar junto a la puerta o ventana a monitorear

En el extremo del Raspberry se debe conectar un cable por un pin GND y el otro en cualquier pin GPIO. Para encontrar los pins y su función puedes usar el siguiente esquema

Ésta es la conexión que hice

Como verán tengo conectadas más cosas, así que destaqué en rojo las conexiones del sensor, que corresponden a los pines 7 (GPIO4) y 9 (GND).

Con las conexiones realizadas ahora pasaré a la parte de software

Programación

Aquí usé la librería de GPIO para python con el siguiente código

import time
import RPi.GPIO as io

io.setmode(io.BCM)

door_pin = 4

io.setup(door_pin, io.IN, pull_up_down=io.PUD_UP)

while True:
        if io.input(door_pin):
                print(«PUERTA ABIERTA!»)
        time.sleep(0.5)

La variable door_pin está fijada con el valor del pin BCM

Finalmente basta con ejecutar la aplicación con python nombrescript.py y activar el sensor abriendo la puerta, se mostrará el mensaje “PUERTA ABIERTA!” cada 0,5 segundos mientras la puerta esté abierta, si la cierras dejará de aparecer el mensaje.

Ahora modificaré el código para que además de mostrar ese mensaje active un relé

import time
import RPi.GPIO as io

io.setmode(io.BCM)

door_pin = 4
rele_pin = 21

io.setup(door_pin, io.IN, pull_up_down=io.PUD_UP) 
io.setup(rele_pin, io.OUT)

while True:
        if io.input(door_pin):
                print(«PUERTA ABIERTA!»)
                time.sleep(1.5)
                io.output(rele_pin, False)
        else:
                io.output(rele_pin, True)
        time.sleep(0.5)

El relé está configurado para que por defecto esté desactivado, por lo que al activar la puerta enciende el relé y viceversa. En caso de que esté configurado a la inversa el relé basta invertir el valor pasado al pin (io.output(rele_pin, XX) intercambiar False por True y viceversa en las dos veces que aparece en el código)

Aquí están destacados los pines correspondientes al relé en verde

2 = DCC, 39 = GND, 40 = GPIO21

Hace unos días compré un Relé (o Relay como se dice en inglés) con la idea de controlar circuitos eléctricos, inicialmente encender y apagar una lámpara (220V).

Materiales

• Raspberry PI (yo usé el 2 B+, pero también debería funcionar con el 1)
• Un relé, la cantidad de canales de éste dependerá de cuántos circuitos quieran controlar.
• Cables para conectar el relé con el raspberry a los pines GPIO.

Relé de 2 canales, aquí estoy sólo usando uno.

Raspberry PI 2, he tenido que quitar la tapa de la carcasa para tener acceso a los pines GPIO. Como SO tiene instalado Raspbian en una microSD de 8 GB.

Éste es el resultado final

Para llegar a ese resultado son 2 partes, primero la conexión del relé al circuito a controlar y al raspberry, y luego la programación del raspberry para controlar el relé.

Cada canal (corresponde a cada “caja azul”) del relé tiene 3 conexiones

En el central debe ir uno de los cables y el segundo puede ir en el primero o tercero, según si deseas que el circuito esté abierto o cerrado cuando el relé está apagado o no está recibiendo energía (estado “por defecto”). Eso lo puedes diferenciar según las líneas que están unidas en el pin 2-3 y para el pin 1 no lo está.

En mi caso para probar dejé conectado el 2-3, para que quede cerrado el circuito por defecto.

Para probar conecté los extremos de los cables a una lámpara y a un enchufe y como por defecto está cerrado el circuito la lámpara se encendió. Si conectaron los 1-2 la lámpara debería permanecer apagada.

Ahora debo proceder a conectar los cables para el Raspberry (no olvides desconectar el circuito primero)

Para ello usé un cable como éste

En el relé los pines están etiquetados GND-IN1-IN2-VCC. El primero y el último son para energizar el relé y el segundo y tercero corresponden a los canales, cuya cantidad corresponderá a la cantidad de canales del relé que hayas comprado.

Como sólo ocuparé el primer canal conectaré únicamente el IN1.

Por el lado del Raspberry he conectado estos pines

De izquierda a derecha corresponden al relé los VCC-GND-IN1, correspondientes a los pines 2 (DC 5v), 6 (GND) y 18 (GPIO 24) del Raspberry.

Finalmente falta configurar el Raspberry para controle el puerto GPIO, para ello utilicé Raspbian que instalé. Una vez instalado puedes entrar por SSH o por terminal conectando monitor y teclado.

Primero tienes que instalar la librería “wiringPi”, la que proveerá de la utilidad “gpio”. Ejecuta estos comandos

apt-get install git-core
clone git://git.drogon.net/wiringPi
cd wiringPi/
./build

Ya tienes instalado wiringPi, ahora para inicializar el pin debes correr este comando

gpio -g mode 24 out

Y ahora para encender

gpio write 5 1

Y para apagar

gpio write 5 0

La explicación de los números la puedes obtener con el comando “gpio readall”

Para comodidad puedes poner estos tres comandos en scripts para correrlos más fácilmente