Si bien Android Automotive lleva anunciado desde 2017, recién el año pasado llegó al mercado el primer coche con Android Automotive. Por si te lo estás preguntando, Android Automotive no es lo mismo que Android Auto. Mientras que este último es una simple interfaz que necesita conectarse con tu móvil para realizar la mayoría de funciones, Android Automotive es un sistema operativo completo que está 100% integrado al vehículo, por lo que no necesita de ningún dispositivo externo para llevar a cabo sus funciones.
Esta implementación más profunda de Android en los coches permite hacer cosas geniales como abrir las puertas, encender el aire acondicionado o activar la calefacción del coche con tan solo pedírselo al Asistente de Google. Por esa razón, hay tanto entusiasmo en la industria automotriz en torno a Android Automotive. Lastimosamente, aún son muy pocos los fabricantes que han lanzado, o que tienen pensado lanzar, coches con esta versión de Android para vehículos.
Para poner remedio a esta situación, una nueva empresa llamada Snapp Automotive ha demostrado que se puede añadir Android Automotive a cualquier coche con un Raspberry Pi. De hecho, la empresa creó su propio Raspberry Pi con este sistema operativo y explicaron cómo lo hicieron paso por paso. Eso sí, no lo presentaron como un tutorial para cualquier persona ni mucho menos, sino como una guía para los interesados en el tema de desarrollo.
Cómo instalar Android Automotive OS 11 en un Raspberry Pi
Para instalar Android Automotive OS 11 en un Raspberry Pi con el método de Snapp Automotive necesitarás un Raspberry Pi 4 Modelo B de 4 GB y una pantalla táctil Waveshare de 10,1″ (o similares). Se usaron 4 GB de RAM porque esta versión de Android para coches está basada en Android 11 que exige más de 2 GB de RAM. La pantalla táctil, por otro lado, es necesaria para ver y controlar todas las acciones del sistema operativo. También se requiere una memoria USB para arrancar el sistema.
En total, la inversión para crear la plataforma que propone Snapp Automotive (considerando también los gastos en cables, memoria USB, etc.) fue de 200 euros.
Compilación de Android 11
Para compilar el Android 11 a usar en el Raspberry Pi necesitas un hardware razonablemente potente. Los creadores de Snapp Automotive usaron un PC con Debian 10. Lo primero que hicieron fue ejecutar el siguiente comando para instalar los paquetes adicionales que se necesitan:
- apt-get install -y git-core gnupg flex bison build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig libncurses5 procps gcc-aarch64-linux-gnu libssl-dev bc fdisk eject
Una vez instalados estos elementos, se comprueba el código fuente del repositorio de Google para la versión etiquetada como android11-qpr2-release siguiendo las instrucciones de Google. Cuando se llegue a la fase de repo init hay que ejecutar:
- repo init -u https://android.googlesource.com/platform/manifest -b android11-qpr2-release
Después de ejecutar repo init hay que añadir los cambios de Android RPi y Snapp Automotive a la compilación. Para conseguir las modificaciones necesarias, se debe añadir un manifiesto local a la compilación, por lo que hay que ejecutar:
- git clone https://github.com/snappautomotive/firmware_rpi-local_manifests.git .repo/local_manifests -b sa-main
Para finalizar, ejecutamos repo sync como se recomienda en las instrucciones de Google. Una vez que la sincronización del repositorio se ha completado, hay un conjunto de modificaciones manuales que tendrás que hacer. Puedes encontrar las instrucciones en la Wiki de Android RPi.
Construyendo el kernel Linux de Android
Hasta aquí, el proyecto Android RPi ya ha creado una compilación del kernel compatible con Android que estará en su árbol de código fuente. Para construir el kernel debes ejecutar los siguientes comandos:
- $ cd kernel/arpi
- $ ARCH=arm64 scripts/kconfig/merge_config.sh arch/arm64/configs/bcm2711_defconfig kernel/configs/android-base.config kernel/configs/android-recommended.config
- $ ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- make Image.gz
- $ ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- DTC_FLAGS=”-@” make broadcom/bcm2711-rpi-4-b.dtb
- $ ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- DTC_FLAGS=”-@” make overlays/vc4-kms-v3d-pi4.dtbo
- $ cd ../..
Creación de la imagen de Android Automotive
Ahora, para crear una imagen completa de Android Automotive solo debes usar estos comandos:
- $ source build/envsetup.sh
- $ lunch snapp_car_rpi4-userdebug
- $ make -j6 ramdisk systemimage vendorimage
Vale la pena aclarar que se usa -j6 en un PC con cuatro núcleos de CPU. Si tienes una máquina con más núcleos, puedes aumentar este número.
Preparando la memoria USB
Ahora hay que poner la imagen creada en una memoria USB de arranque (un pendrive, no una tarjeta SD) de al menos 16 GB. Si tienes una de más espacio, mejor porque así podrás instalar más apps. Las particiones deben ser creadas usando fdisk con tamaños y tipos como los siguientes:
- Partición 1: W95 FAT32(LBA), 128 MB, arrancable.
- Partición 2: Linux, 2GB.
- Partición 3: Linux, 128 MB.
- Partición 4: Linux, todo el espacio restante.
Tu memoria USB aparecerá probablemente como un dispositivo que empieza por /dev/sd en tu PC. A partir de ahora nos referiremos a las particiones como /dev/sdX1 y tendrás que sustituir la X por la letra apropiada que tu PC asigne al dispositivo. El siguiente paso es crear el sistema de archivos en las dos particiones que tendrán archivos escritos en ellas (sdX1 y sdX4). Escribiremos una imagen de disco en las otras dos particiones por lo que no necesitamos crear manualmente los sistemas de archivos para ellos. Para crear los sistemas de archivos ejecuta lo siguiente:
- $ mkfs.vfat /dev/sdX1
- $ mkfs.ext4 /dev/sdX4
Ahora hay que montar la primera partición y añadir todos los archivos necesarios para que el Raspberry Pi arranque. Para ello, ejecuta los siguientes comandos desde la comprobación del código fuente:
- $ mount /dev/sdX1 /mnt
- $ mkdir /mnt/overlays
- $ cp device/snappautomotive/rpi/boot/* /mnt
- $ cp kernel/arpi/arch/arm64/boot/Image.gz /mnt
- $ cp kernel/arpi/arch/arm64/boot/dts/broadcom/bcm2711-rpi-4-b.dtb /mnt
- $ cp kernel/arpi/arch/arm64/boot/dts/overlays/vc4-kms-v3d-pi4.dtbo /mnt/overlays/
- $ cp out/target/product/rpi/ramdisk.img /mnt
- $ umount /mnt
- $ sync
Toques finales y puesta en marcha
El último paso es copiar las imágenes del sistema y del proveedor en las particiones sdX2 y sdX3 de la memoria USB. Esto se hace ejecutando los siguientes comandos desde dentro de la comprobación del código fuente:
- $ dd if=out/target/product/rpi/system.img of=/dev/sdX2 bs=1M
- $ dd if=out/target/product/rpi/vendor.img of=/dev/sdX3 bs=1M
- $ sync
- $ eject /dev/sdX
Ahora, ya puedes extraer la memoria USB, colocarla en un puerto USB del Raspberry Pi y arrancarla. El primer arranque puede tardar un par de minutos más o menos mientras Android optimiza las aplicaciones en la memoria USB.
Y así es como se crea una compilación de Android Automotive OS 11 para un Raspberry Pi con pantalla táctil mediante el método de Snapp Automotive. ¿Qué se puede hacer ahora? Pues instalar las aplicaciones de Android Automotive que quieras en el Raspberry Pi y usar todo lo que ofrece este sistema operativo.
Evidentemente, no podrás usar funciones que nacen de la integración profunda con el coche (como abrir las puertas con tu voz), pero al menos no tendrás que tener tu móvil conectado para usar Android en el coche. Para más información acerca de esta guía de Snapp Automotive, pincha el enlace de la fuente.
Fuente | Medium
