• Tutoriais Alunos

Android para Raspbery Pi 3

Começando

Para seguir esse tutorial é necessário:

Motivação

A motivação inicial era compilar Android em uma FPGA e o tema foi escolhido pois o grupo tinha o desejo de compilar um software de alto nível em uma placa de desenvolvimento. Entretanto, por dificuldades técnicas, foi decidido migrar para uma Raspberry Pi, que por ser mais barata e acessível ao público, existe uma quantidade significativa de referências, viabilizando a criação de aplicações.

Contexto

O sistema operacional Android é extremamente popular e muito presente em dispositivos mobile, presente em cerca de 70% de celulares no mundo. Este tutorial consiste em embarcar o Android utilizando LineageOS, uma distribuição open source de Android, numa Raspberry Pi 3 B+.

Android

Android é um sistema operacional baseado no kernel do linux no qual é possível compilar o seu próprio sistema para utilizar em um celular ou placas de desenvolvimento.

Raspberry Pi

Raspberry Pi é um microcomputador do estilo System On a Chip que permite fazer tudo que um computador faz com baixo custo. O modelo utilizado neste roteiro é o Raspberry Pi 3 B+, a qual possui um processador 64-bit quad-core de 1.4GHz, dual-band wireless e bluetooth. Ou seja, adequada para aplicações de automação e IOT.

Raspberry PI3

Instalação

Warning

Alguns dos passos exigem alto poder computacional, caso você não tenha uma máquina com o armazenamento mínimo necessário ou com um bom processador, sugerimos a utilização de uma máquina na nuvem.

Sugestão

Para esse tutorial, utilizamos uma instância da AWS t2.2xlarge.

Configurando o ambiente

Uma vez no Ubuntu 18.04, será necessário a instalação de alguns pacotes essênciais, para saber mais, entre na página disponibilizada pelo Andoid. 

$ sudo apt-get install 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 openjdk-8-jdk gcc-arm-linux-gnueabihf libssl-dev python-mako
Instale também o repo e rode o comando: 
$ repo init --depth=1 -u https://android.googlesource.com/platform/manifest -b android-10.0.0_r25

Clone o repositório com as configurações da Raspberry para Android:

$ git clone https://github.com/csimmonds/a4rpi-local-manifest .repo/local_manifests -b android10

Tip

Para aumentar a velocidade de instalação use o argumento -c (branch atual) e -jthreadcount 

$ repo sync -c j8

Warning

Pausa para café, esta etapa demora cerca de 1- 2 horas.

Configurando o U-boot

U-boot é um bootloader Opens Source utilizado em sistemas de linux embarcados. Os comandos abaixo criam a nossa imagem boot que será utilizada para carregar o Android. 

$ cd $ANDROID_BUILD_TOP/u-boot
$ PATH=$HOME/gcc-linaro-7.4.1-2019.02-x86_64_arm-linux-gnueabihf/bin:$PATH
$ export ARCH=arm
$ export CROSS_COMPILE=arm-linux-gnueabihf-
$ cp $ANDROID_BUILD_TOP/device/rpiorg/rpi3/u-boot/rpi_3_32b_android_defconfig configs
$ make rpi_3_32b_android_defconfig
$ make

Compilando o kernel

É necessário compilar o Kernel que será responsável pela criação do Android. Também é criada a partição DTBS, device tree blob source, que é responsável por disponibilizar a estrutura do hardware. Como Android pode ser utilizado em dispositivos diferentes, Device Tree Overlays (DTOs) são necessários para mapear o hardware para o sistema.

Rode os comandos: 

$ PATH=$HOME/gcc-linaro-7.4.1-2019.02-x86_64_arm-linux-gnueabihf/bin:$PATH
$ export ARCH=arm
$ export CROSS_COMPILE=arm-linux-gnueabihf-
$ cd $ANDROID_BUILD_TOP/kernel/rpi
$ scripts/kconfig/merge_config.sh arch/arm/configs/bcm2709_defconfig \
kernel/configs/android-base.config kernel/configs/android-recommended.config
$ make -j $(nproc) zImage
$ cp arch/arm/boot/zImage $ANDROID_BUILD_TOP/device/rpiorg/rpi3
$ make dtbs
$ croot

Compilando o Android

Com as imagens criadas anteriormente (zImage, boot e dtbs), agora temos tudo pronto para compilar o Android em si. Para isso, é necessário configurar as variáveis de ambiente e fazer a montagem. 

$ source build/envsetup.sh
$ lunch aosp_rpi3-eng
$ m

Warning

Esta etapa pode demorar em torno de 2 horas.

A explicação dos comandos utilizadas pode ser encontrada aqui.
É criado as imagens VendorImage, SystemImage e UserData que posteriormente serão escritas no cartão de memória.

SD Card

A última etapa é criar as partições e passar as imagens criadas no passo anterior para partições no SD card, que são elas:

  • Vendor: Drivers que conectam hardware e software;
  • System: Sistema Android;
  • UserData: Usado para resetar as configurações;
  • Boot: Arquivos de inicialização, como os DTOs e configurações do Uboot.

Warning

Caso você tenha feito as etapas anteriores em uma instância virtual, siga os passos abaixo, caso contrário, siga para a etapa Instalando Android localmente.

Instalando Android na nuvem

Como não é possível conectar um cartão SD diretamente em uma instância na nuvem, deve ser criado uma partição virtual para simular um cartão SD.
Primeiro, é necessário criar uma imagem vazia com o tamanho disponível do seu cartão SD.

$ dd if=/dev/zero of=zero.img bs=4M count=1536

Com isso, criaremos a partição virtual a partir dessa imagem: 

$ sudo losetup -P -f --show zero.img
Ao término do comando, a sua saída será o nome da sua partição virtual. No nosso caso, obtivemos loop6.

Dentro da pasta do Android, modifique o arquivo /scripts/write-sdcard-rpi3.sh, alterando mmcblk0 para o nome da sua partição virtual.

...

# Unmount any partitions that have been automounted
if [ $DRIVE == "loop6" ]; then
        sudo umount /dev/${DRIVE}*
        BOOT_PART=/dev/${DRIVE}p1
        SYSTEM_PART=/dev/${DRIVE}p3
        VENDOR_PART=/dev/${DRIVE}p4
        USER_PART=/dev/${DRIVE}p5
else
        sudo umount /dev/${DRIVE}[1-9]
        BOOT_PART=/dev/${DRIVE}1
        SYSTEM_PART=/dev/${DRIVE}3
        VENDOR_PART=/dev/${DRIVE}4
        USER_PART=/dev/${DRIVE}5
fi

...

Faça um dd para transformar o Android instalado na partição virtual em uma imagem. 

$ dd if=/dev/loop6 of=android.img bs=4M

Tip

Mais uma vez, troque loop6 pelo nome de sua partição virtual.

Existem várias maneiras para transferir arquivos de uma instância virtual para outra máquina, indicamos utilizar Secure Copy Protocol (SCP).
Na sua máquina, de posse da key utilizada na instância, basta rodar o comando abaixo:

$ scp -i <chave_de_acesso> ubuntu@<ip_maquina>:/home/ubuntu/android.img .

Tip

Note que /home/ubuntu/android.img é o nosso path da imagem criada pelo dd, mude para o seu path correspondente.

Warning

Essa etapa pode demorar em torno de 10 minutos dependendo da sua conexão.

O último passo é transferir o arquivo android.img, que foi copiado para a sua máquina, para o SD card. Para isso, insira o cartão de memória e utilize o comando lsblk para saber o nome do seu dispositivo e rode:

$ dd if=android.img of=/dev/<nome_SDcard> bs=4M

Instalando Android localmente

Nota

Este tópico só deve ser realizado se você está fazendo localmente.

Insira o SD Card no seu computador e use comando lsblk para saber o nome do dispositivo. No exemplo abaixo, o nome do dispositivo é sdc.

Agora, para instalar o Android no SD Card é necessário rodar o comando na pasta root do projeto: 

$ scripts/write-sdcard-rpi3.sh <nome_SDcard>

Rodando Android na Raspberry

Ao inserir o SD Card na Raspberry e conectá-la à uma fonte de energia via cabo Micro USB, se tudo foi feito corretamente, o Android deve inicializar, podendo ser observado ao conectar uma da saída de vídeo (HDMI), como visto abaixo:



Pronto! Você tem um Andoid rodando em uma Raspberry Pi. Para utilização completa dos recursos disponibilizados pelo Android, o usuário pode optar por utilizar um mouse com entrada USB ou até mesmo uma tela touch, ambos conectados diretamente na Raspberry.