# Projeto Bomba
Este projeto tem como objetivo descaracterizar aparelhos de IPTV, com o intuito de remover o sistema original e substituí-lo por Linux. Os aparelhos descaracterizados, então, serão utilizados para aplicações como sinalização digital.
O trabalho realizado aqui faz parte da disciplina Sistemas Embarcados e Internet das Coisas, do curso de Ciência da Computação da Universidade Estadual do Oeste do Paraná, campus de Cascavel.
Alunos envolvidos:
* Gabriel Jared de Barros Amorim
* Luiz Eduardo Garzon de Oliveira
* Luiz Fernando Becher de Araujo
* Matheus Lucas Ferreira Jacinto
# Descaracterização da TV box "MDTV PRO+ 8K"
Especificações do dispositivo:
* Processador Rockchip RK3228A;
* 1GB de memória RAM;
* 8GB de armazenamento eMMC;
* Placa R29-MXQ-LP3.
É possível utilizar o tutorial [CSC Armbian for RK322X TV Boxes](https://forum.armbian.com/topic/12656-csc-armbian-for-rk322x-tv-boxes/) para instalar o Armbian nesta TV box. O grande problema com esse modelo é que a saída de vídeo HDMI não funciona a partir de uma inicialização direta do Armbian. Para obter vídeo, é necessário inicializar o aparelho com o cartão SD do Multitool, selecionar o opção de reinicializar, remover o cartão SD e esperar que o Armbian inicialize.
# Descaracterização da TV box "R69"
Especificações:
* Processador Amlogic S905W;
* 1GB de memória RAM;
* 8GB de armazenamento eMMC;
* Placa T95S2_AML_20210809_V1.3;
* Entrar em DFU: Conectar o cabo USB na porta de trás. Antes de ligar na toma, fazer curto entre algum ground e o sétimo contato do eMMC, contando a partir do canto com uma bolinha branca no chip. Remover curto após o dispositivo ser reconhecido pelo computador.
Esta TV box também pode utilizar o Armbian como sistema operacional. Para isso, siga o tutorial [Installation Instructions for TV Boxes with Amlogic CPUs](https://forum.armbian.com/topic/17106-installation-instructions-for-tv-boxes-with-amlogic-cpus/) para instalar o Armbian. Este modelo teve uma compatibilidade quase excelente com o Armbian. No entanto, após uma atualização via `apt upgrade`, o dispositivo liga, mas fica preso em uma tela preta que antecede o boot do Linux. (Recomendo pausar as atualizações de kernel depois de instalar o Armbian, para evitar que situações parecidas aconteçam. Isso pode ser feito pelo comando `armbian-config`.)
# Descaracterização das TV box "in Xplus!"
Especificações:
* Processador Rockchip RK3228A;
* 2GB de memória RAM;
* 8GB de armazenamento eMMC;
* Placa HTT-RK-MINI-V7.0-2020.09;
* Entrar em DFU (Mask Rom Mode): Conectar o cabo USB na porta mais próxima do leitor de cartão. Antes de ligar na toma, fazer curto entre algum ground e o sétimo contato do eMMC, contando a partir do canto com uma bolinha branca no chip. Remover curto após o dispositivo ser reconhecido pelo computador.
Primeiramente, foi utilizado o tutorial [CSC Armbian for RK322X TV Boxes](https://forum.armbian.com/topic/12656-csc-armbian-for-rk322x-tv-boxes/) para criar uma mídia de instalação do Armbian e gravá-lo no eMMC.
Vale notar que um adesivo no corpo do aparelho dizia que o SoC era um RK3229, no Armbian o SoC foi reconhecido como RK3228A e no CPU-Z do sistema operacional original o SoC foi reconhecido como RK3066.
O dispositivo inicializou com vídeo após a instalação. No entanto, o dmesg imediatamente começou a despejar mensagens de erro durante os logs do SystemD.
Não havia conexão com a Internet após o login, mesmo com o cabo de rede conectado. Ao utilizar a ancoragem USB através de um celular Android, nenhum IP foi atribuído à TV box, apesar da interface de rede USB estar lista no comando `ip a`. O NetworkManager apresentava mensagens de falha (que foram vistas a partir do comando `sudo systemctl status NetworkManager`) e, durante o processo de desligamento, o NetworkManager foi fechado forçadamente após o timeout do SystemD, indicando um provável travamento.
Este problema, entretanto, não era persistente. Em algumas inicializações, o dispositivo era capaz de utilizar as interfaces de rede sem problemas.
### Caçando o bug da interface de rede
Links úteis:
* [Flag do driver Ethernet para RK3066 (.config)](https://www.kernelconfig.io/config_emac_rockchip?q=&kernelversion=6.1.57&arch=arm)
* [Flag do driver Ethernet para RK3288, que inclui RK3228 (.config)](https://www.kernelconfig.io/config_dwmac_rockchip?q=&kernelversion=6.1.57&arch=arm)
* [Datasheet do Wi-Fi (SV6256P)](http://www.icomm-semi.com/Uploads/Temp/files/2022-08-19/SV6256P%20Datasheet_V1.0.pdf)
Suspeitas:
* O kernel está tentando usar um driver errado (DWMAC em vez de EMAC ou EMAC em vez de DWMAC)?
* O SoC foi alterado para se passar por outro, o que gerou a confusão com o modelo do SoC?
* O arquivo DTB está errado?
* O driver de alguma outra interface de rede está travando o NetworkManager?
* Culpa do Armbian?
### Resolução
Foi compilado e instalado o kernel 6.1.57 (passo a passo de como compilar um kernel ARM no apêndice) com alguns patches do Armbian para RK322X, mas não todos (vale lembrar que um dos patches, que também é utilizado pelo Armbian, é proveniente do projeto LibreELEC). Foram evitados os patches que, por alguma razão, modificavam os arquivos Kconfig e Makefile (a maioria deles, pelo menos — uma vez que poderiam adicionar drivers e outros módulos instáveis ao kernel). O arquivo `.config` utilizado como base foi o que estava na partição `/boot` da instalação do Armbian. Um rootfs puro, do Debian 12, foi utilizado como sistema a ser inicializado.
Funcionou!
OBS: Não foi criado um novo esquema de partição MBR durante esse processo. Utilizamos o que já estava no eMMC, que foi criado pelo Armbian. Apenas deletamos a partição existente e criamos uma partição de boot e uma partição raiz. Descobrimos, mais tarde, que gerar um novo esquema de partição MBR, pelo `parted` ou pelo `fdisk`, faz com que o aparelho pare de inicializar sem estar com o cartão SD do Multitool conectado.
Qual o veredito, então? Desta vez não houve nenhum hardware de Wi-Fi listado no `ip a`. Provavelmente, um driver problemático para tal dispositivo foi compilado junto ao kernel do Armbian, o que causou o aparente travamento do NetworkManager. Embora este apontamento precise ser analisado com mais cuidado, é um bom ponto de partida para melhorar o suporte à placa HTT-RK-MINI-V7.0-2020.09.
Links:
* [Download do kernel 6.1.57](https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.1.57.tar.xz)
* [Patch único para o kernel 6.1.57](https://www.dropbox.com/scl/fi/dftz18hi1ywb0f8kaz1m2/0001-linux-6.1.57.patch?rlkey=to2zzcpytcpxk5mn3y45u7j42&dl=0)
* [Arquivo de configuração para compilar o kernel 6.1.57](https://www.dropbox.com/scl/fi/fxwu3kp0n2tcbe7seoptb/kernel-config-bomba-rk322x?rlkey=ul77xehr512n8szdchvj3epv5&dl=0)
# Avaliando aplicações de sinalização digital
Os softwares de digital signage são programas projetados para controlar e gerenciar conteúdo exibido em telas de sinalização digital. Esses softwares oferecem uma variedade de funcionalidades para criar, programar, distribuir e monitorar o conteúdo exibido em displays digitais. Buscamos encontrar um software compatível que atendesse as necessidades como:
* **Gerenciamento de conteúdo:** Permitem o upload e a organização de vídeos, imagens, textos, feeds de redes sociais e outros tipos de conteúdo para exibição.
* **Agendamento:** Possibilitam a programação de quando e onde o conteúdo será exibido, permitindo configurar horários específicos ou sequências de exibição.
* **Personalização e design:** Oferecem ferramentas para criar layouts, templates ou designs personalizados para o conteúdo a ser exibido nas telas.
* **Controle remoto:** Permitem o controle das telas a partir de uma localização remota, facilitando a atualização e modificação do conteúdo em tempo real.
* **Monitoramento e análise:** Fornecem métricas e análises sobre a performance do conteúdo, como quantas vezes foi exibido, tempo médio de visualização, entre outros dados relevantes.
A fim de implementar o sinalizador digital vários softwares foram analisados e testados levando em conta os seguintes aspectos: código aberto, tipo de licença de uso, compatibilidade com os sistemas operacionais e processo de instalação e uso.
Existem diversas plataformas e softwares de digital signage disponíveis no mercado, cada um com suas próprias características e funcionalidades específicas, atendendo desde pequenos negócios até grandes redes de sinalização digital.
## Xibo
* Licença: AGPLv3, a Licença Pública Affero General (AGPL), que é uma licença de software livre e de código aberto projetada para garantir que o código-fonte de um programa esteja disponível para usuários finais, mesmo quando o software é usado como um serviço em rede. se o software coberto pela licença for modificado e usados para fornecer serviços interativos através de uma rede, o código-fonte dessas modificações deve ser disponibilizado para usuários remotos quando solicitado. quaisquer modificações ou melhorias feitas ao software sob a AGPLv3 sejam distribuídas juntamente com o código-fonte correspondente, mesmo se o software for usado como um serviço online. Não permite que os usuários carreguem e executem suas próprias versões modificadas no dispositivo pois quando o software modificado é oferecido como um serviço através de uma rede, os usuários devem ter acesso ao código-fonte da versão modificada do software.
* Sistema Operacional: Windows e Linux.
* Tipo de Código: Open Source.
É uma aplicação web PHP/MySQL, com JavaScript nativo e jQuery no front-end. Possui entre os planos Professional, Business ou Enterprise, para desfrutar de todos os recursos CMS Xibo hospedado na nuvem, juntamente com o Xibo para Android player e suporte e serviços de help.
Xibo para Linux requer uma distribuição Linux de 64 bits que suporte a plataforma de distribuição Snapcraft. CPU Intel/AMD de 64 bits necessária. Recomendado um dispositivo com 4GB de RAM e uma CPU i3 ou superior.
## PiSignage
* Licença: A licença do player custa uma taxa única de US $ 25, que vem com atualizações gratuitas e transferíveis. White Label Server para construir a própria sinalização com Soluções baseadas em servidor de código aberto (MIT License: licença de software livre e de código aberto).
* Sistema Operacional: Linux.
* Tipo de Código: O piSignage tem uma versão open source chamada "PiSignage Community Edition", que é distribuída sob a licença AGPLv3 (Affero General Public License versão 3). Isso significa que, de acordo com os termos dessa licença, o código-fonte do PiSignage Community Edition é disponibilizado publicamente, e os usuários têm permissão para visualizar, modificar e distribuir o software, desde que cumpram os requisitos da licença. enquanto a versão Pro pode ter um modelo de licenciamento proprietário com funcionalidades extras, mas sem acesso ao código-fonte.
PiSignage Player é baseado no Raspberry Pi. Podemos criar exibições piSignage usando qualquer player baseado em Linux que suporte o navegador chromium usando o aplicativo web piSignage.
A seguir estão os componentes sugeridos necessários para montar o piSignage Player:
* Raspberry Pi modelo 3 (recomendado, embora outros modelos sejam suportados)
* Fonte de alimentação USB com cabo micro USB (com capacidade de 2A, alimentação USB da TV pode não ser suficiente)
* Classe 10, 8GB + cartão microSD de fornecedor de renome
* Cabo HDMI de boa qualidade (CEC suportado)
* Cabo LAN ou adaptadores USB wi-fi compatíveis com Pi se o Wi-Fi não estiver integrado
## Concerto Signage
* Licença: Licença de Software Apache v2. Isso significa que o Concerto é um software de código aberto que você pode redistribuir e/ou modificar sob os termos da Licença. permitindo o uso, modificação, distribuição e sublicenciamento do software, incluindo software proprietário. A licença permite o uso do software tanto para fins comerciais quanto não comerciais.
* Sistema Operacional: Linux.
* Tipo de Código: software de código aberto
Concerto é um aplicativo de sinalização digital baseado na web licenciado sob a licença Apache e escrito usando a estrutura de programação Ruby on Rails. Ele gira o conteúdo gráfico, textual e de vídeo carregado por meio de um modelo que é acessado por computadores que executam um navegador da web. Qualquer computador e sistema operacional capaz de exibir o aplicativo web Concerto em um navegador pode ser usado.
Necessita de um servidor web para usar para distribuir conteúdo que pode executar aplicativos Ruby on Rails e um banco de dados (MySQL, PostgreSQL, SQLite, etc), para começar. Para cada monitor público do Concerto, é necessário um computador com a capacidade de emitir vídeo para um monitor externo, bem como o próprio hardware de exibição.
## Display Monkey
* Licença: MIT License.
* Sistema Operacional: Linux e Windows (qualquer sistema com suporte aos navegadores compatíveis).
* Tipo de Código: Código Aberto.
Display Monkey é uma solução de sinalização digital baseada em navegador. oferece suporte aos seguintes navegadores: Firefox, Chrome, Safári, IE (8 terminam), Raspberry Pi Epifania, Navegador Samsung Smart TV (série 6 e superior). Assim como o Xibo, o Display Monkey é um software de código aberto, o que significa que é gratuito para usar, modificar e adaptar conforme as necessidades individuais.
## OpenSignage
* Licença: O software Opensignage é regido por licenças de assinatura.
* Sistema Operacional: Windows, android e Linux (para players dedicados na loja do software).
* Tipo de Código: O software Opensignage não é de código aberto, mas é uma solução robusta e segura para comunicação de tela.
Para usar o Opensignage é preciso de uma tela e um player (de mídia). O player está conectado à tela e à Internet. No ambiente de gerenciamento online, também conhecido como CMS onde são criadas as playlist(s). O CMS pode ser acessado de qualquer computador com conexão à Internet.
Software seguro e estável. Não é preciso de (quase) nenhum conhecimento técnico para montar sua transmissão de sinalização digital. o software Opensignage não está disponível para jogadores do Raspberry Pi. o software de sinalização digital está atualmente disponível para dispositivos Windows e Android. não está disponível para Linux. osso software de sinalização digital está atualmente disponível para dispositivos Windows e Android. As assinaturas do Opensignage estão atualmente em uma base "por player".
## Screenly
* Licença e Tipo de Código: O Screenly Open Source Edition é um software de sinalização digital de código aberto, licenciado sob a licença GPLv2 (General Public License version 2). Isso significa que o código-fonte do Screenly Open Source Edition está disponível publicamente e os usuários têm permissão para visualizar, modificar e distribuir o software de acordo com os termos da licença GPL.
* O Screenly OSE Plus é uma versão comercial, oferecem funcionalidades adicionais e suporte. A licença para o Screenly OSE Plus é uma licença proprietária, o que significa que o código-fonte pode não ser acessível ou modificável pelos usuários, já que é uma versão paga do software.
* Sistema Operacional: Compatíveis ao raspberryPi.
O Screenly é uma plataforma de sinalização digital que oferece soluções para exibição de conteúdo em telas remotas. Utiliza uma abordagem baseada em nuvem para o gerenciamento de conteúdo, permitindo o acesso e o controle remoto das telas através de uma interface web. Ele é projetado para funcionar com dispositivos Raspberry Pi. Oferece recursos para gerenciar e programar o conteúdo exibido em telas remotas, permitindo alterações e atualizações em tempo real. O Screenly é uma escolha popular devido à sua interface amigável e à capacidade de gerenciar eficientemente várias telas remotas, proporcionando um controle simplificado sobre o conteúdo exibido em cada uma delas.
## DigitalSignage.com
* Licença: soluções de software como serviço (SaaS). Essas plataformas geralmente não têm um tipo de licença de software tradicional, pois os usuários não adquirem uma cópia do software para instalação ou modificação local. Em vez disso, os usuários acessam o serviço online por meio de uma assinatura ou conta paga.
* Sistema Operacional: Linux e Windows.
* Tipo de Código: Proprietário. Quanto ao código-fonte, em serviços de SaaS como o DigitalSignage.com, o código subjacente não está disponível para os usuários finais, já que eles não interagem diretamente com o software em nível de código.
o DigitalSignage.com é uma plataforma de sinalização digital baseada na nuvem que oferece soluções para criação, gerenciamento e exibição de conteúdo em telas digitais. Essa plataforma é projetada para ser acessada e controlada através de um navegador da web, oferecendo uma abordagem de gerenciamento remoto para campanhas de sinalização digital.
Baseado em cloud. mediaCLOUD é um Digital Signage baseado em nuvem (também conhecido como SaaS ou software como serviço). Todos os seus arquivos de mídia (vídeos, animações etc.) são armazenados em servidores e transmitidos para baixo para obter armazenado localmente em cache dentro de players / computadores locais.
Tanto a edição GRATUITA quanto a Enterprise permitem usar um número ILIMITADO de telas. Não é cobrado por licença como a maioria das outras empresas de Digital Signage fazem. Qualquer computador, com qualquer sistema operacional, executando um navegador da Web comumente suportado com Flash Player 10+
## Conclusão
Após vários testes realizados com os diferentes tipos de softwares sinalizadores digitais, encontramos problemas como limitações nas licenças, pagamento por assinaturas, compatibilidade com sistemas Linux, compatibilidade com a arquitetura ARMv7, disponibilidade de dependências, etc. Optamos, por fim, pelo PiSignage.
# Sobre o PiSignage
Como dito anteriormente, a ferramenta de sinalização digital que incorporamos foi o PiSignage. Apesar de limitar o registro de players a duas licenças gratuitas, nada impede o uso de players sem licença, porém com a presença de uma marca d'água. Ele destacou-se como a opção mais adequada, especialmente, pela compatibilidade com a arquitetura ARMv7 em imagens baseadas no Raspberry Pi OS para as placas Raspberry Pi Zero e Raspberry Pi 1.
## Players
O PiSignage proporciona duas abordagens distintas de players: via página web ou um sistema nativo para Raspberry Pi. Para criar um player por meio da web, basta acessar a página dedicada (https://pisignage.com/player2/) e configurar as opções desejadas, fornecendo o IP do servidor, se estivéssemos usando um servidor dedicado, ou cadastrando o player no painel do servidor do PiSignage.
No caso do player dedicado, a instalação da imagem no dispositivo e a configuração do IP do servidor foram passos essenciais. Alternativamente, como mencionado anteriormente, tínhamos a opção de cadastrar o player no servidor do PiSignage para usufruir dos serviços oferecidos por eles, em detrimento de um servidor dedicado local.
Realizamos testes para avaliar a eficiência nos principais navegadores para Linux: Chromium e Firefox. Embora ambos os navegadores tenham apresentado resultados satisfatórios, o Chromium destacou-se pela sua performance superior em comparação ao Firefox. Os testes envolveram a exibição de diversos tipos de mídia, incluindo vídeos, imagens em diferentes formatos, links e páginas HTML.
No que diz respeito ao sistema nativo, observamos um desempenho superior em relação aos navegadores, apesar de algumas limitações. Devido ao kernel antigo da Rockchip, o player nativo não oferece um driver de kernel opensource para o decoder de vídeo via hardware da Rockchip. Portanto, sem um driver compatível que possa ser chamado por um driver de espaço de usuário, como o VA-API, utilizado pelo FFmpeg. A decodificação via software, por conta da performance bastante limitada da CPU, não é viável para maioria das resolução e formatos de vídeos mais complexos. No entanto, para a exibição de imagens, HTML e links, ele se mostrou notavelmente mais ágil em comparação aos navegadores.
# Instalação do PiSignage
## Instalação do servidor local em uma máquina x86_64
No Debian 12, basta digitar os comandos abaixo:
```
sudo apt update && sudo apt install docker-compose -y
```
```
wget https://raw.githubusercontent.com/colloqi/pisignage-server/master/docker-compose.yml
```
```
sudo docker-compose -f ./docker-compose.yml up -d
```
Feito isso, torna-se possível acessar o painel de controle do PiSignage através do navegador, utilizando o IP ou domínio do servidor, mais a porta 3000. O login padrão é `pi`, tanto para o usuário quanto para a senha.
## Instalação do player em aparelhos RK322X
Infelizmente, essa etapa não é tão simples quanto a anterior. O player do PiSignage foi pensado para placas Raspberry Pi e, portanto, precisamos trocar o kernel da imagem para que ela se torne compatível com os dispositivos que pretendemos utilizar. Visto que até o kernel do Armbian possui problemas de compatibilidades com os SoCs RK322X, mesmo aplicando uma série de patches, o mais seguro é utilizar um kernel da própria Rockchip. Compilar um kernel da Rockchip é um processo completamente amaldiçoado e tentar replicar as alterações da Rockchip no kernel mainline não é muito viável. Por isso, escolhemos o caminho mais fácil: utilizar um kernel 4.4 pré-compilado da Rockchip, que está disponível no Multitool, sob a pena de abrir mão da aceleração gráfica nativa para GPUs Mali 4XX (via driver Lima e Mesa) dos kernels mais recentes (acima do 5.2).
Se você possui uma imagem de backup do PiSignage já configurada, basta copiá-la para a pasta`backups` do Multitool e inicializar o aparelho pelo cartão SD. Em seguida, selecionar a opção de restaurar backup e selecionar a imagem para gravar no eMMC. Se não, você precisará instalar o PiSignage manualmente, utilizando o passo a passo das subseções abaixo.
### Obtendo as imagens do PiSignage e do Multitool
Vamos baixar as imagens e descompactá-las.
```
wget "https://drive.google.com/u/0/uc?id=1w3xcL0xFHU486bzzriImTuiwg9NHjudq&export=download&confirm=t&uuid=cea3840a-f1f0-45b0-a198-acb4851da30a&at=AB6BwCDWPXwOwduUpZsXq-UIUuDS:1701015681454" -O pisignage_2.9.7_pizero.img.zip
```
```
unzip pisignage_2.9.7_pizero.img.zip
```
```
rm pisignage_2.9.7_pizero.img.zip
```
```
wget https://users.armbian.com/jock/rk322x/multitool/multitool.img.xz
```
```
xz -d multitool.img.xz
```
### Modificando a imagem do PiSignage
Nossas imagens (os arquivos .img) são, de certa forma, "dispositivo de armazenamento virtuais". Usando o comando `losetup`, podemos utilizá-las no Linux como dispositivos de armazenamento conectados ao sistema.
A imagem do PiSignage pode ser montada com:
```
sudo losetup -P /dev/loop100 pisignage_2.9.7_pizero.img
```
A partir de agora, as partições da imagem do PiSignage já estão visíveis no diretório /dev. Estamos interessados somente na partição raiz (a segunda partição). Para montá-la, basta criar um ponto de montagem com o comando `mkdir` e montar a partição com o comando `mount`.
```
sudo mkdir /mnt/pisignage
```
```
sudo mount /dev/loop100p2 /mnt/pisignage
```
Para interagir com o sistema Linux dentro da imagem do PiSignage, precisamos dar suporte à execução de binários ARM à nossa máquina. Podemos fazer isso com o QEMU.
```
sudo apt install binfmt-support qemu-user-static
```
```
sudo cp /usr/bin/qemu-arm-static /mnt/pisignage/usr/bin
```
Com isso, podemos acesar o Raspbarry Pi OS da imagem e dizer para ele parar de atualizar o seu bootloader e o seu kernel, já que iremos utilizar os arquivos de boot do Multitool e não queremos que nada estrague durante uma atualização.
```
sudo chroot /mnt/pisignage
```
```
apt-mark hold raspberrypi-bootloader raspberrypi-kernel raspberrypi-kernel-headers
```
```
exit
```
Com isso, a imagem está pronta para ser gravada. Assim, podemos desmontar a partição em uso e remover o ponto de montagem.
```
sudo umount /mnt/pisignage
```
```
sudo rm /mnt/pisignage -r
```
Também vamos desconectar a imagem do PiSignage do sistema.
```
sudo losetup -d /dev/loop100
```
### Gravando o Multitool no cartão SD
Aqui você vai precisar saber localizar o seu cartão SD no seu sistema.
A forma mais intuitiva é utilizando a aplicação [Balena Etcher](https://etcher.balena.io/) para gravar a imagem. Se você estiver usando Linux, baixe a versão Appimage. Depois de baixada, vá nas propriedades do arquivo clicando com o botão direito sobre ele e permita a execução. Então, com dois cliques, execute-o e realize as etapas que a aplicação pede, selecionando a imagem do multitool e o cartão SD.
Se você conhece os dispositivos de armazenamento do seu PC e a forma como o Linux identifica cada um deles, pode usar o comando:
```
dd if=multitool.img of=/dev/o_seu_cartão_sd
```
Antes de copiar as imagens do PiSignage e do Multitool para o cartão SD, recomendo iniciar a TV box com o cartão SD que você acabou de gravar conectado, para ver se ele está funcionando e, também, para redimensionar as partições de acordo com o espaço disponível (processo automático feito durante o boot). Feito isso, desligue a TV pela opção “Shutdown” e reconecte o cartão SD no seu PC. Copie as imagens para a pasta `images`.
### Caso o cartão SD não tenha espaço para as imagens
É o fim do mundo? Não, ele só ficou um pouco mais complicado. E você vai precisar de um pendrive com capacidade suficiente para armazenar as imagens.
A ideia aqui é fazer o Multitool enxergar um diretório de imagens no seu pendrive e não no cartão SD. Mas lembre-se de usar um sistema de arquivos adequado no pendrive. XFS e BTRFS não têm suporte por conta da idade do kernel. Há suporte para FAT32, mas se você está tendo problemas com o tamanho das imagens, não use FAT32. EXT4 funciona. Não testei ExFAT e nem NTFS, mas devem funcionar.
No seu pendrive, crie uma pasta chamada `images` e copie as imagens do Multitool e do PiSignage dentro dela. Depois disso, conecte tanto o cartão SD quanto o pendrive na TV box. Quando o Multitool inicializar, escolha a opção "Drop to Bash shell" para ter acesso ao terminal.
Vamos montar a partição principal do Multitool em /mnt.
```
mount /dev/mmcblk0p1 /mnt
```
E também precisamos de um ponto de montagem para o nosso pendrive.
```
mkdir /mnt/usb
```
Agora temos que montá-lo. Se você tem um pendrive com apenas uma partição, provavelmente você terá que montar o dispositivo de bloco `/dev/sda1`. Mas nem sempre é o caso, então você pode tentar usar o comando `lsblk` para ver qual dos dispositivos listados tem o tamanho da partição em que você copiou as imagens.
Para montar o pendrive:
```
mount /dev/sda1 /mnt/usb
```
Para fazer a pasta do Multitool ser "direcionada" para a pasta do pendrive\:
```
mount /mnt/usb/images /mnt/images --bind
```
Tudo pronto. Basta voltar para a interface do Multitool com o comando:
```
exit
```
### Gravando o PiSignage
Na verdade, vamos gravar o Multitool primeiro no eMMC da TV box. O motivo para isso é que precisamos de um esquema de partição MBR compatível, o qual ainda não sabemos como criar. Sendo assim, vamos utilizar o MBR do Multitool.
Primeiro, use a opção de realizar backup do armazenamento interno da TV box (caso precise restaurar depois). Segundo, selecione a opção de limpar o eMMC. Terceiro, selecione a opção de gravar no eMMC, escolhendo o arquivo `multitool.img` na etapa de seleção de imagem.
Após a conclusão, desligue a TV box e remova o cartão SD. Ligue-a novamente. Precisamos deixar que a TV box inicie pelo armazenamento interno para redimensionar as partições do Multitool. Com ela inicializada, insira o cartão SD e, no Multitool, escolha a opção de reinicializar. Assim, voltaremos a executar o Multitool pelo cartão SD.
Escolha a opção “Drop to Bash shell” para ter acesso ao terminal.
Caso suas imagens estejam em um pendrive, execute os comandos da seção anterior novamente. Caso não, execute o comando abaixo:
```
mount /dev/mmcblk0p1 /mnt
```
No eMMC, precisamos criar uma apartição com exatamente a mesma quantidade de setores que a partição raiz do PiSignage (considerando que ambos os sistemas de arquivos possuem setores de mesmo tamanho). Para isso, vamos estudar a imagem do PiSignage com o comando:
```
fdisk -l /mnt/images/pisignage_2.9.7_pizero.img
```
A minha saída foi a seguinte:
```
Disk pisignage_2.9.7_pizero.img: 5,25 GiB, 5641338880 bytes, 11018240 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xe8af6eb2
Device Boot Start End Sectors Size Id Type
pisignage_2.9.7_pizero.img1 8192 532479 524288 256M c FAT32 W95 (LBA)
pisignage_2.9.7_pizero.img2 532480 11018239 10485760 5G 83 Linux
```
A partição raiz, que é a segunda e também a maior entre as duas disponíveis (pisignage_2.9.7_pizero.img2), possui 10485760 setores. Vamos anotar esse valor para mais tarde.
Precisamos agora modificar o esquema de partição do eMMC com:
```
fdisk /dev/mmcblk2
```
Use o comando abaixo para obter as informações do seu eMMC:
```
p
```
No meu caso, a saída foi:
```
Disk /dev/mmcblk2: 7.3 GiB, 7818182656 bytes, 15269888 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x32595f23
Device Boot Start End Sectors Size Id Type
/dev/mmcblk2p1 275032 15269887 14994856 7.2G 7 HPFS/NTFS/exFAT
/dev/mmcblk2p2 * 143960 275031 131072 64M c W95 FAT32 (LBA)
/dev/mmcblk2p3 32768 143959 111192 54.3M 83 Linux
```
Note que a partição `mmcblk2p2` (a segunda) possui um asterisco na coluna `Boot`, portanto ela é a partição de boot do Multitool e devemos mantê-la. Anote o valor da coluna `End` correspondente à ela (no meu caso, 275031). As demais partições são desnecessárias e iremos descartá-las. Por isso, deletaremos a primeira partição:
```
d
```
```
1
```
Responda Y caso o `fdisk` questione. Vamos deletar também a terceira partição:
```
d
```
```
3
```
Novamente, responda Y caso o `fdisk` questione. O próximo passo é criar uma partição com a mesma quantidade de setores da partição raiz do PiSignage, que comece logo após o fim da partição de boot.
```
n
```
```
p
```
```
1
```
Insira agora, como primeiro setor, o valor de `End` da partição de boot que você anotou, incrementando uma unidade. No meu caso, 275031 + 1:
```
275032
```
Para o setor final, some o valor anterior com a quantidade de setores da partição raiz do PiSignage, que você também anotou anteriormente. No meu caso, 275032 + 10485760:
```
10760792
```
Responda Y caso o `fdisk` questione.
Para gravar as alterações:
```
w
```
Vamos copiar o conteúdo a partição raiz da imagem do PiSignage para a partição que acabamos de criar no eMMC, utilizando os comandos:
```
losetup -P /dev/loop0 /mnt/images/pisignage_2.9.7_pizero.img
```
```
dd if=/dev/loop0p2 of=/dev/mmcblk2p1
```
Devemos montar as partições do eMMC para terminar de configurar o PiSignage.
```
mkdir /mnt/emmc
```
```
mount /dev/mmcblk2p1 /mnt/emmc
```
```
mount /dev/mmcblk2p2 /mnt/emmc/boot
```
O processo de boot depende que as partições sejam indicadas corretamente. Por isso, devemos obter o PARTUUID da partição raiz do PiSignage:
```
blkid -o value -s PARTUUID /dev/mmcblk2p1
```
E o PARTUUID da partição de boot:
```
blkid -o value -s PARTUUID /dev/mmcblk2p2
```
Anote os valores obtidos. Agora vamos editar o primeiro arquivo.
```
nano /mnt/emmc/boot/extlinux/extlinux.conf
```
Substitua o valor em `root=PARTUUID=` pelo valor que você anotou anteriormente para o PARTUUID da partição raiz do PiSignage. No final da mesma linha, adicione o parâmetro `video=HDMI-A-1:1280x720` para limitar a resolução da tela à resolução HD e, assim, evitar de sobrecarregar a CPU com a renderização via software. Use Ctrl + S para salvar e Ctrl + X para sair do editor.
Editaremos agora o segundo e útimo arquivo:
```
nano /mnt/emmc/etc/fstab
```
Substitua o valor de `PARTUUID=` da linha que contém ´/´ pelo PARTUUID da partição raiz do PiSignage obtido anteriormente. Na linha que contém `/boot`, substitua o PARTUUID pelo PARTUUID da partição de boot também obtido anteriormente. Use Ctrl + S para salvar e Ctrl + X para sair do editor.
Tudo pronto! Para voltar para a interface do Multitool, execute:
```
exit
```
Você pode selecionar a opção de fazer backup do eMMC para reutilizar a mesma instalação em outras TV box com chip RK322X. Esse backup ficará salvo no cartão SD e você poderá copiá-lo para algum lugar mais seguro com o seu computador.
Agora basta reiniciar e remover o cartão SD, na pasta `backups`, e também o pendrive, caso esteja utilizando um. Parabéns, você tem um player do PiSignage!
## Conectando o player da TV box ao servidor local
Com a TV box iniciada, o player carregado e um teclado USB conectado, precione a tecla F6. Selecione a opção de configuração do servidor, no menu que surgiu, e aperte enter. Na caixa de texto, apague seu conteúdo e insira o IP do servidor local mais a porta 3000.
## Arquivos HTML para a playlist da Unioeste
Para criação dos arquivos HTML utilizados pelo PiSignage, foram utilizados:
Horario_aula: neste arquivo estão inseridas basicamente 4 imagens com os horários de cada ano do curso de Ciência da Computação, onde todas as imagens estão contidas em um container, e dentro deste container as tags que apontam o endereço das imagens. As imagens estão hospedadas no site imgur.com, sendo endereço de cada imagem:
* Primeiro ano: https://i.imgur.com/c8Kz2pc_d.jpg?maxwidth=520&shape=thumb&fidelity=high
* Segundo ano: https://i.imgur.com/ZjTEoby_d.jpg?maxwidth=520&shape=thumb&fidelity=high
* Terceiro ano: https://i.imgur.com/LLFe3Tm_d.jpg?maxwidth=520&shape=thumb&fidelity=high
* Quarto ano: https://i.imgur.com/W9bFxlk_d.jpg?maxwidth=520&shape=thumb&fidelity=high
Horario_lab: estes arquivos ficaram meio “cru”, nele está presente apenas uma tabela composta por dias da semana, horário das aulas e o laboratório referente à tabela, e seu conteúdo deverá ser o nome da disciplina, curso etc., que tenha reservado o laboratório relacionado.
Logo_unio: Presente apenas a logo da Universidade Estadual do Oeste do Paraná.
Previsao_tempo: Arquivo que contêm a previsão do tempo da cidade em que o campus está localizado, foi utilizado o código aberto do site openweathermap.org para a criação, então os ícones, api e código base é de mérito deles.
Para configurar este arquivo de forma adequada, foi necessário alterar alguns dados na função getWeather() e convertToWeekday(), os passos em getWeather() são:
* Alterar a constante “city” para o valor “Cascavel”;
* Alterar a constante “units” para o valor “metric”;
* Alterar a constante “lang” para “pt”.
Os passos em convertToWeekday() são:
* Alterar a constante “days” para "Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sab".
OBS: Os arquivos relacionados aos horários dos laboratórios e logo da universidade carecem de estilização, estão visualmente simples e incompletos até o momento.
O repositório onde os arquivos se encontram é: https://github.com/JaredGabriel2001/Embarcados
# Apêndice
## Compilar o kernel Linux
Compilar o kernel Linux pode ser um jeito de otimizar o sistema operacional para o seu dispositivo ou ativar e desativar drivers que podem estar relacionados com algum problema.
Antes de tudo, é preciso obter o código fonte do kernel. Não é uma etapa complicada e pode ser feita de duas formas: clonando o [repositório do Linux](https://github.com/torvalds/linux) ou baixando algum dos arquivos compacatados no site [kernel.org](https://www.kernel.org/).
Caso clone o repositório, use o comando `git` para clonar alguma versão em estágio de lançamento do kernel, de preferência LTS (Long-Term Support). Por exemplo:
```
git clone --depth 1 --branch v6.1 https://github.com/torvalds/linux.git
```
Caso baixe pelo site [kernel.org](https://www.kernel.org/), basta encontrar a versão desejada na lista e clicar no link "tarball" correspondente. Depois que o download for concluído, extraia o arquivo.
Aqui será considerada a compilação apenas para a versão 6.1 do kernel e para a arquitetura ARMv7 com suporte à hard float (cálculo de ponto flutuante via hardware).
### Preparando o sistema operacional de compilação
Como a campilação aqui será realizada em uma máquina Intel, que possui arquitetura x86 e não é compatível com a arquitetura ARM, será necessário instalar pacotes de compilação cruzada no sistema operacional. Além disso, é necessário instalar algumas bibliotecas que são dependências para a compilação do kernel. Não conheço todas elas, mas, em casos de erro durante o comando `make` por conta de includes não satisfeitos, vale uma busca na Internet para instalar as bibliotecas que faltam no seu sistema.
No Debian 12 (e talvez nas versões mais recentes do Ubuntu), as dependências são:
```
sudo apt install crossbuild-essential-armhf libncurses5-dev libssl-dev bison flex
```
### Aplicando patches ao kernel
Em alguns casos, é necessário aplicar patches para que o kernel funcione adequadamente em alguns dispositivos. Para aplicar um patch, basta entrar no diretório do kernel extraído/clonado e executar o comando:
```
git apply /caminho/para/o/arquivo.patch
```
Geralmente, os arquivos de patch não funcionam perfeitamente e precisam de alguma interação do usuário para serem aplicados. Para forçar a aplicação de um patch (as alterações não aplicadas deverão ser aplicadas manualmente):
```
git apply /caminho/para/o/arquivo.patch --reject
```
### Preparando o ambiente de compilação
Aqui serão definidas algumas variáveis de terminal para lembrar ao `make` que estamos fazendo compilação cruzada para ARMv7. Essas variáveis são esquecidas toda vez que o terminal é fechado e precisam ser definidas novamente quando um novo terminal for aberto.
Para definir a arquitetura alvo:
```
export ARCH=arm
```
Para definir a compilação cruzada para ARMv7 com suporte à hard float:
```
export CROSS_COMPILE=arm-linux-gnueabihf-
```
### Gerando arquivo .config
Antes de tudo, lembre-se que é necessário preparar o ambiente de compilação (seção acima) e acessar o diretório que você clonou ou extraiu através do terminal.
Para gerar o arquivo de configuração de compilação do kernel Linux, `.config`, que diz quais componentes e drivers serão incluídos na imagem do kernel a ser compilada, há duas opções:
#### 1ª. Usar um .config pronto
Copiar um arquivo de configuração que você criou, modificou ou baixou pela Internet. Uma dica de onde encontrá-los é no [repositório da ferramenta de compilação do Armbian](https://github.com/paolosabatino/armbian-build/tree/main/config/kernel). Neste repositório, há configurações para vários SoC diferentes. Com o arquivo de configuração em mãos, basta copiá-lo para o diretório do Linux baixado ou clonado, renomeando-o para `.config`.
Por exemplo:
```
cp ~/Downloads/linux-rk322x-current.config .config
```
Depois, execute o comando abaixo para definir qualquer configuração faltando.
```
make oldconfig
```
#### 2ª. Gerar um .config a partir de um defconfig do kernel
Um defconfig (default configuration) é um arquivo que fornece uma configuração padrão para compilar o kernel para uma arquitetura de hardware específica ou para uma determinada plataforma. O objetivo principal de um arquivo defconfig é fornecer um ponto de partida para a compilação do kernel, economizando tempo e esforço.
Para gerar o `.config` desta maneira, basta digitar o comando `make` mais o nome de um arquivo defconfig armazenado em `arch/arm/configs/`.
Por exemplo:
```
make multi_v7_defconfig
```
Para personalizar o arquivo `.config` gerado, caso queira, execute o comando:
```
make menuconfig
```
### Compilando o kernel
Não esqueça que o parâmetro após `-j` é a quantidade de threads a serem usadas na compilação. Escolha um valor igual ao número de threads da sua CPU.
```
make zImage dtbs modules -j 8
```
## Criar um rootfs do Debian
Para isso, você pode seguir [esse tutorial](https://akhileshmoghe.github.io/_post/linux/debian_minimal_rootfs).
## Instalar o kernel Linux compilado
OBS: Seção potencialmente incompleta. Não tente em casa a não ser que saiba o que está fazendo!
```
export KERNEL_RELEASE=$( make kernelrelease )
```
```
make modules_install
```
```
cp -v .config /boot/config-${KERNEL_RELEASE}
```
```
cp -v arch/arm/boot/zImage /boot/zImage-${KERNEL_RELEASE}
```
```
mkdir -p /boot/dtb-${KERNEL_RELEASE}
```
```
cp -v arch/arm/boot/dts/rk3*.dtb /boot/dtb-${KERNEL_RELEASE}
```
```
cp -v System.map /boot/System.map-${KERNEL_RELEASE}
```
```
cd /boot
```
```
mkdir extlinux
```
```
touch extlinux/extlinux.conf
```
```
echo "LABEL Linux" > extlinux/extlinux.conf
```
```
echo " LINUX /zImage-${KERNEL_RELEASE}" >> extlinux/extlinux.conf
```
```
echo " INITRD /initrd.img-${KERNEL_RELEASE}" >> extlinux/extlinux.conf
```
```
echo " FDT /dtb-${KERNEL_RELEASE}/rk322x-box.dtb" >> extlinux/extlinux.conf
```
Não esqueça de substituir o valor do PARTUUID no comando abaixo para corresponder com o da sua partição.
```
echo " APPEND earlyprintk root=PARTUUID=a80cc823-02 rootwait rootfstype=ext4 init=/sbin/init loglevel=0 fsck.repair=yes video=HDMI-A-1:1280x720" >> extlinux/extlinux.conf
```
```
mkimage -A arm -O linux -T kernel -C none -a 0x600f0000 -e 0x600f0000 -n ${KERNEL_RELEASE} -d /boot/zImage-${KERNEL_RELEASE} /boot/uImage-${KERNEL_RELEASE}
```
```
update-initramfs -c -k ${KERNEL_RELEASE}
```
```
mkimage -A arm -O linux -T ramdisk -a 0x0 -e 0x0 -n initrd.img-${KERNEL_RELEASE} -d initrd.img-${KERNEL_RELEASE} uInitrd-${KERNEL_RELEASE}
```
Sign in with Wallet
Connect another wallet