Raspberry Pi - Utilizando UART do barramento de pinos

Estou em um projeto ultra-secreto que envolve pela primeira vez uma board com sistema embarcado além de comunicação paralela com micro-controladora via UART (serial). Vou falar nesse post sobre os dados não-confidenciais, que se concentram na manipulação do hardware, onde estou usando Emdebian.

Esse tutorial é antigo, pode servir para sistemas que mantém o arquivo /etc/inittab e sistemas mais velhos, mas para os sistemas atuais não serve.

Das necessidades

Precisei de coisas bastante específicas, como um login sem senha seguido da execução de um programa para fazer leitura de dados seriais via USB (mais especificamente, HID). A recepção de dados sucede desse modo, enquanto o envio de uma resposta se dá por UART, utilizando-se dos pinos seriais disponíveis no barramento do Raspberry, trocando informações com uma micro-controladora (inicialmente, um Arduino no protótipo). A primeira coisa a considerar é que o Raspberry trabalha em 3.3v e não é tolerante a 5v, de forma que se faz necessário uma conversão de nível lógico.
Enfatizando: NÃO LIGUE 5v aos pinos do Raspberry, pois ele não tem nenhum tipo de proteção a sobrecarga.

Entretanto, primariamente foi necessário validar uma comunicação serial. Para tal, utilizei o "canivete suiço" BusPirate, citado mais adiante em detalhes. Os tópicos para esse post então são:

• Login sem senha
• Execução de programa automaticamente
• Modificação no sistema para utilização dos pinos seriais
• Utilização do conversor de nível lógico
• Sniffing de barramento com o BusPirate
• Exemplo de comunicação entre o Arduino Leonardo e o RaspBerry
• Configuração wi-fi no Emdebian utilizando o arquivo

interfaces

Pronto para a diversão? Então, mãos à obra.

Raspbian

Obviamente, a primeira tarefa é ter um sistema inicializável que possa ser manipulado. Baixei o sistema e o instalei no cartão SD. Essa é uma vantagem do Raspberry em relação às boards SoC (System on Chip), porque facilita muito a manipulação do sistema. Por outro lado, a perda fica por conta da lentidão do boot. O que pode ajudar um bocado em relação a isso é utilizar um cartão com a categoria mais alta. Para quem não sabe, a partir dos cartões micro-sd de 4GB é chamado sdhc, onde H é de High e C é Capacity, ou seja, cartões de alta capacidade de armazenamento. Entretanto, não é esse fator que define a categoria e sim a velocidade de gravação de dados. Essa especificação conhecida como "Speed Class", afere a velocidade de gravação. Por exemplo, a classe 4 grava 4MB/s, enquanto classe 16 (provavelmente o maior até o momento desse post) grava 16MB/s. Um excelente material a respeito pode ser encontrado nesse link, na Wikipedia.

Claro que esse não é o único fator a influenciar no tempo de boot, pois além da leitura do sistema para a memória, ainda há o processamento para inicialização de serviços e seus respectivos delays. Enfim...

Instalando o sistema no SD

Existem diversas distribuições para Raspberry, mas a minha escolhida foi o Debian Wheezy, baixada deste link.

A instalação é basicamente a descompressão do arquivo e um dd para o device de destino. No meu caso, o dispositivo aparece como mmcblk0:

dd bs=1M if=arquivo_do_sistema.img of=/dev/mmcblk0

Atualizações podem ser conseguidas com apt-get upgrade e o primeiro boot é mais lento que os subsequentes (saudades da trema).
Tente memorizar a senha de root padrão: raspberry :-)
Todos os procedimentos chatos de configuração de pacotes podem ser feito com o dpkg:

#timezone
dpkg-reconfigure tzdata
#keyboard
dpkg-reconfigure console-data
#locales
dpkg-reconfigure locales

Programas podem ser instalados via apt-get como em uma distribuição Debian qualquer. Para compilar programas para ele, a coisa é um pouco mais embaixo. Recomendo a leitura de meus posts sobre buildroot e embedded, mas a grosso modo, deve-se construir um ambiente de desenvolvimento a partir do buildroot (preferencialmente) ou WRT. A parte triste é que muita coisa sequer compilará e o que compilar provavelmente necessitará de adaptações no código.

Para quem pretende realmente se aventurar em embedded, recomendo alguns livros (em inglês) que comprei na Amazon e me tem sido úteis:

• Building Embedded Linux Systems
• Embedded Linux Primer
• Embedded Linux System - Design and Development

E introdutóriamente ao Raspberry (também adquirido na Amazon):

• Raspberry Pi User Guide

Login sem senha

Como em qualquer sistema GNU/Linux, muitas configurações do boot podem ser feitas no arquivo /etc/inittab, como o login sem senha, comportamento do ctrl+alt+del, runlevel e consoles seriais. Para o login sem senha comente a linha como a seguir, adicionando a linha posterior em substituição:

#1:2345:respawn:/sbin/getty --noclear 38    400 tty1
1:2345:respawn:/bin/login -f root tty1 /    dev/tty1 2>&1

Claro, para que surtam os efeitos, um reboot é necessário - ou ainda, essas modificações podem ser feitas em qualquer sistema (preferencialmente Linux para evitar o final de linha MS, o que pode ocasionar algum erro).

Execução automática de programas

Então, tendo um login automático como no exemplo, um programa pode ser rodado de um arquivo qualquer relacionado ao shell em questão; no caso do bash, pode ser tanto o .bash_login, .bash_profile ou .bashrc do usuário root. Para evitar que o script ou programa seja interrompido e o usuário tenha acesso ao console, existem várias opções. Uma delas é NÃO executar o processo em segundo plano (seguindo o comando de um &) e na linha posterior adicionar um reboot. A outra opção ao reboot, é adicionar umecho 'b' >sysrq-trigger, o que fará um boot imediato do sistema, sem o processo de interrupção dos serviços (pode ser bastante prejudicial ao sistema de arquivos, mas é efetivo em relação ao bloqueio de acesso ao console).

Como utilizar os pinos seriais para a comunicação UART

Mais uma vez recorremos ao /etc/inittab. Aqui tive algumas dúvidas pela questão de que os consoles seriais são atrelados à saída gráfica do sistema operacional, que são as tty. Logo, pensei em acesso via arquivo descritor, tal como o dispositivo serial ACM0 ou USB0, criado na comunicação USBSerial apenas na interrupção do pino. A única certeza que eu tinha é de que esses pinos do barramento do Raspberry não podem ser acessados diretamente no hardware tal como é feito em micro-controladoras, considerando que o hardware trabalha em modo protegido e é gerenciado pelo kernel space. Mas em uma pesquisa básica, tudo ficou muito claro. Além do inittab, há uma outra modificação necessária no arquivo da partição de boot chamado cmdline. Esse arquivo contém strings sem poder de execução, e é utilizado para passar ao kernel parâmetros que devem ser reconhecidos durante o processo de boot para executar tarefas especificas. Por exemplo no Phantom, o cmdline tem aproximadamente 30 parâmetros possíveis para automatizar backup. No nosso caso, a modificação será feita para remover a referência ao dispositivo ttyAMA0. Faça um backup do arquivo cmdline.txt e seguidamente remove as referências console=ttyAMA0,115200 e kgdboc=ttyAMA0,115200. Existem diversos sites dando essas dicas, mas ainda é necessário fazer uma busca requintada no google para chegar aos devidos resultados.
Para finalizar, edite o inittab e comente a linha que aponta o dispositivo para o console serial:

#Spawn a getty on Raspberry Pi serial line
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

A comunicação será feita a 115200; o dispositivo já está configurado e pronto para uso. Agora um script básico em python para ficar em loop enviando um byte na rede para que possa ser lido pelo BusPirate:

import serial,datetime,os,sys,time
porta="/dev/ttyAMA0"

serialport = serial.Serial(porta,115200)
serialport.open()


time.sleep(1)
while True:
    serialport.write('1')
    time.sleep(2)

No video o script já está em execução no Raspberry.

Sniffing UART com BusPirate

O BusPirate é um projeto da Dangerous Prototypes. Não se encontra no Brasil, não tem jeito, tem que importar e correr o risco de pagar 100% de impostos, assim como eu. Fiz a compra no SeeedStudio (com 3 letras 'e' mesmo). Lá também comprei o cabo (fundamental) e o case.

Detalhes sobre a configuração UART podem ser vistas nesse link do manual do BusPirate, mas nesse vídeo mostro o suficiente para a comunicação serial em modo de ponte transparente.

Acessei o Raspberry por ssh, utilizando um adaptador wi-fi que funcionou muito bem. A configuração foi feita utilizando o arquivo /etc/network/interfaces, simplesmente adicionando esses parâmetros:

auto wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-ssid "suaRedeWireless"
wpa-psk "senhaSecreta"

Fiz troca de chaves para não precisar digitar senha e no video a seguir exibo a comunicação serial sendo monitorada pelo BusPirate utilizando o programa GtkTerm para a conexão. Repare que falei no video que a porta utilizada foi a ttyACMO, mas na verdade a porta utilizada está no código mais acima, e é a ttyAMA0.

ATUALIZAÇÃO: Esse foi meu primeiro artigo com Raspberry. No menu do header você encontrará montes de outros, divirta-se!

Se gostou, não deixe de compartilhar; dê seu like no video e inscreva-se no nosso canal Manual do Maker Brasil no YouTube.

Próximo post a caminho!