macos

Aunque soy un fanático de Apple, el Raspberry Pi siempre ha tenido un lugar especial en mi corazón principalmente por la posibilidad de realizar proyectos de demótica doméstica, servidores de medios, NAS caseros, etc.

En ocasiones puede ser necesario disponer de una emulación de la Raspberry Pi en nuestro Mac para poder probar programas, scripts, etc sin necesidad de encender dicho dispositivo.

Mi primera intención fue virtualizarlo utilizando VirtualBox, sin embargo dicho software no funciona con sistemas operativos basados en ARM como por ejemplo Raspbian.

Por lo tanto fue necesario buscar otra opción cuya única alternativa es utilizar un emulador. En internet es posible encontrar numerosas guías de cómo emular Raspbian en MacOS, pero varias de ellas tenían errores y me costó bastante lograr el objetivo.

Por esta razón, creí necesario publicar cómo logre emular Raspian en MacOS exitosamente utilizando para ello el software Qemu.

1. Descargar e instalar Homebrew y Qemu

Algunas guías indican que es necesario tener instalado Xcode para poder instalar Qemu, sin embrago este es un requerimiento innecesario. Basta instalar Homebrew tras lo cual podremos instalar Qemu sin necesidad de instalar Xcode, y por lo demás Homebrew nos permitirá instalar muchas otras cosas que Apple no nos entrega en MacOS, que pueden ser interesantes para quienes gustan de usar el Terminal y que veremos más adelante. Además, si no eres desarrollador de aplicaciones para iOS o MacOS, no volverás a utilizar Xcode nunca más y sólo ocupará espacio en disco.

Lo primero es abrir un ventana de Terminal, y escribir el siguiente comando el cual permitirá la instalación de Homebrew

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Una vez instalado Hombre podremos instalar Qemu, escribiendo el siguiente comando

brew install qemu

Con esto ya tendremos instalado Qemu, listo para poder emular Raspbian en nuestro Mac

2. Descargar Raspbian y el Kernel para emularlo en Qemu

En este punto encontré varios problemas, algunas guías no eran lo suficientemente claras, o asumían que quien estaba instalando Qemu para emular Raspbian tenían un conocimiento avanzado, y otros eran demasiado antiguos los cuales si bien funcionaban corrían versiones antiguas de Raspbian, o ejecutaban comandos «deprecados» que hacían que la emulación «crasheara». Encontré incluso algunos scripts sh que me ayudaron a entender qué errores estaba cometiendo porque justamente tenían errores.

Para emular Raspbian en Qemu es necesario 2 archivos. Primero una versión de Raspbian y segundo un kernel el cual permite que Raspbian corra emulado dentro de Qemu. Sin embargo, el kernel es específico para cada versión de Raspbian. La última versión de Raspbian disponible en el sitio de la Raspberry Pi Foundation es Raspbian Jessie 2017-02-27. La última versión del kernel para Rapbian en Quemu es compatible con Rsapbian Jessie 2016-11-25, por lo tanto es necesario descargar esa versión específica para tener éxito en su emulación.

El kernel para correr Raspbian en Qemu no e mantenido por Raspberry Pi Foundation ni por Qemu, sino por un usuario de Github llamado dhruvvyas90.

Los links para la descarga de ambos son los siguientes

https://github.com/dhruvvyas90/qemu-rpi-kernel/raw/master/kernel-qemu-4.4.34-jessie

http://downloads.raspberrypi.org/raspbian/images/raspbian-2016-11-29/2016-11-25-raspbian-jessie.zip

Es recomendable descargar ambos archivos en una carpeta creada específicamente para dicho efecto. En mi caso los descargué en ~/Mis Programas/Raspberry Pi/

Personalmente, cuando estoy usando el Terminal, prefiero utilizar comandos de Terminal, y por lo tanto obviamente la creación de las carpetas y descarga de dichos archivos también lo hice en el Terminal

cd ~
mkdir Mis\ Programas
mkdir Mis\ Programas/Raspberry\ Pi

Para la descarga de los archivos fue necesario instalar un programa que existe en Linux pero que MacOS no no entrega que es wget, pero gracias a Hombres es tremendamente fácil de instalar

brew install wget

Ahora solo basta descargar los archivos utilizando los siguientes comandos

wget https://github.com/dhruvvyas90/qemu-rpi-kernel/raw/master/kernel-qemu-4.4.34-jessie

wget http://downloads.raspberrypi.org/raspbian/images/raspbian-2016-11-29/2016-11-25-raspbian-jessie.zip

Una vez descargados los archivos tenemos que descomprimir el archivo zip que contiene a Raspbian con el siguiente comando

unzip 2016-11-25-raspbian-jessie.zip

Esto generará el archivo 2016-11-25-raspbian-jessie.img el cual utilizaremos para emular Raspbian utilizando Qemu.

3. Configurar y emular Raspbian en MacOS Sierra utilizando Qemu

Finalente, ya tenemos todo lo necesario para emular Raspbian en MacOS Sierra utilizando Qemu. Ahora solo tenemos que configurar la emulación para que corra adecuadamente en nuestro Mac, lo cual requiere un primer booteo, luego la modificación de algunos archivos del sistema dentro de la emulación, para que todo quede correctamente configurado y después poder bootear Raspbian todas las veces que necesitemos.

3.1 Primer booteo

Es necesario hacer un primer booteo tras el cual tendremos que hacer algunas modificaciones a un par de archivos estando dentro de la emulación en Qemu. Para esto utilizaremos el siguiente comando

qemu-system-arm -kernel kernel-qemu-4.4.34-jessie -cpu arm1176 -m 256 -M versatilepb -no-reboot -serial stdio -append "root=/dev/sda2 panic=1 rootfstype=ext4 elevator=deadline rw init=/bin/bash" -drive "file=2016-11-25-raspbian-jessie.img,index=0,media=disk,format=raw"

Esto iniciará Raspbian y después de menos de un minuto veremos la consola Shell en la ventana en que se está emulando Raspbian

3.2 Modificación de los archivos ./etc/ld.so.preload y ./etc/fstab

Ahora, dentro de la ventana de Qemu en que se está emulando Raspbian, es necesario modificar un par de archivos. Se trata de los archivos ./etc/ld.so.preload y ./etc/fstab.

En el caso de ./etc/ld.so.preload es necesario «comentar» cada una de sus lineas y en el caso de ./etc/fstab es necesario «comentar» todas las entradas que contengan el texto «/dev/mmcblk». Para «comentar» las lineas basta con insertar el texto «# » al principio de cada una de las líneas.

Los comandos para realizar esto son

nano /etc/ld.so.preload
nano /etc/fstab

Recordemos que para salir y grabar los cambios en el editor de textos Nano, es necesario presionar las teclas Ctrl-X y luego Y para confirmar que los cambios sean grabados.

3.3 Segundo booteo

Ahora realizaremos el segundo booteo de Raspbian con lo cual el emulador después de un par de minutos nos mostrará el entorno gráfico de Raspbian. Más adelante veremos cómo se modifica la configuración para bootear sin cargar el entorno gráfico, ya que esto es más adecuado para proyectos de demótica doméstica o de internet de las cosas.

qemu-system-arm -kernel kernel-qemu-4.4.34-jessie -cpu arm1176 -m 256 -M versatilepb -no-reboot -serial stdio -append "root=/dev/sda2 panic=1 rootfstype=ext4 elevator=deadline rw" -drive "file=2016-11-25-raspbian-jessie.img,index=0,media=disk,format=raw" -net user,hostfwd=tcp::5022-:22

Este es el comando que tendremos que utilizar de ahora en adelante cada vez que deseemos correr nuestra emulación de Raspbian en MacOS Sierra, ya que las modificaciones a los archivos realizadas en el paso anterior son permanentes.

Debido a que es muy fácil cometer un error cuando se escribe un comando demasiado largo con demasiadas opciones, preferí transformarlo en un script sh, el cual me permite ejecutar la emulación con un comando más sencillo. Abrí un archivo nuevo utilizando el editor nano, copié el texto siguiente y luego guardé el archivo con el nombre «qemu-raspbian.sh» en la misma carpeta donde están los archivos de imagen de Raspbian y el kernel.

# Define variables
export QEMU=$(which qemu-system-arm)
export RPI_KERNEL=./kernel-qemu-4.4.34-jessie
export RPI_FS=./2016-11-25-raspbian-jessie.img

# Emulate Raspberry Pi
$QEMU -kernel $RPI_KERNEL \
-cpu arm1176 -m 256 \
-M versatilepb -no-reboot -serial stdio \
-append "root=/dev/sda2 panic=1 rootfstype=ext4 elevator=deadline rw" \
-drive "file=$RPI_FS,index=0,media=disk,format=raw" \
-net user,hostfwd=tcp::5022-:22

De esta manera cada vez que quiero emular Raspbian en MacOS con Qemu utilizo el siguiente comando en Terminal

sh qemu-raspbian.sh

Además esto permite que cada vez que aparezca una nueva versión de kernel, basta que modifique la variable asociada al nombre de kernel dentro del script sh.

Por cierto, al emular Raspbian no es posible acceder a la utilización del conector GPIO ya que es un entorno emulado, no es un Raspberry Pi real, pero sirve al menos para probar scripts, programas, compilaciones, etc, cuando no tenemos a mano nuestra Raspberry Pi o simplemente cuando no queremos malograr todo lo que ya hemos hecho con una linea de código mal escrita.

Espero que este tutorial sea de ayuda para quienes como yo, gustan de realizar proyectos con la Raspberry Pi, y en la medida que vayan apareciendo nuevas versiones tanto de Raspbian como del kernel, la iré actualizando. Saludos.

Links:

• Homebrew – The missing package manager for MacOS
• qemu-rpi-kernel by dhruvvyas90 @ GitHub
• Downloads @ Raspberry Pi Foundation