Intel Galileo Linux e Arduino IDE

Infelizmente a Microsoft anunciou o fim do suporte a Windows na plataforma Intel Galileo em 30 de Novembro de 2015. Minha especialidade não é Windows, mas confesso ter ficado um pouco chocado com a notícia porque claro que houve investimento na plataforma, inclusive a Microsoft me selecionou para escrever a respeito da placa de primeira geração enviando-me uma.

Com o abandono da plataforma, resta resgatar a placa com um Linux (o que não é nada mal), mas não é transparente, alguns passos extras serão necessários em se tratando da versão Gen1 da board. Primeiro vamos a uma introdução sobre a placa.

Características

A Intel Galileo possui um processador Quark SoC X1000, relativamente novo e sua arquitetura é x86. Isto é, a mesma arquitetura utilizada em computadores desktop e notebooks. Trata-se de um processador de 32-bits rodando à 400MHz e possui 512MB de RAM. Sua área de flash é generosa (8MB para o firmware) e possui uma área de EEPROM também tentadora (11KB). Suporta cartão micro-sd de até 32GB, possui uma interface ethernet 10/100 e porta USB2.0, além de RS232 e uma mini PCI express.

Na placa encontram-se além da interface ethernet e micro-sd, um slot JTAG, pinos para ICSP, um jack TS para comunicação UART, um micro-usb client e um micro-usb host e as outras coisas que não sei o nome vou chamar de 'etc'.

GPIO

A pinagem é a mesma do Arduino, incluindo 6 entradas analógicas, SPI, I²C, UART e PWM, dando total flexibilidade no desenvolvimento sem reaprendizado.

Com o poder de um sistema operacional, a board se torna um parque de diversões e pode lhe tomar longas horas conforme sua criatividade estiver sendo alimentada pelas possibilidades. A maioria dos sketches para UNO e Leonardo podem ser portados diretamente para o Galileo, e isso é uma das motivações para experimentar uma board dessas, além de que você tem acesso às mais diversas bibliotecas populares do Arduino como EEPROM (que será muito bem vinda nessa board), SD (fundamental também), Ethernet (claro que precisa), WiFi, Wire, SPI, etc. Agora, utilizando um Linux na board, você pode acessá-lo através da chamada system() e ai, meu amigo, estará a um passo da dominação do mundo!

x86 versus ARM

Essa questão polêmica pode gerar muita discussão devido a conceitos envolvidos, inclusive tive um atrito relacionado recentemente. Independente disso, retomo o assunto citando características importantes e às vezes contraditórias.

A plataforma X86 foi criada pela IBM para desktops. A arquitetura X86 tem mais clock e é mais poderosa que ARM se comparando-a desse modo. A diferença fundamental dessas arquiteturas está no set de instruções; ARM é RISC (Reduced Instructions Set Computing) e um X86 até pouco era exclusivamente CISC (Complex Instructions Set Computing).

A plataforma X86 consome mais energia e fim.

Atualizar o firmware do Galileo

Como citei lá no início, a versão GEN1 da Intel Galileo traz a necessidade de uma atualização de firmware antes que possa ser instalado um Linux no micro-sd. Baixe o firmware (32 ou 64 bits, dependendo da arquitetura do seu computador, não da Galileo), descomprima-o e deixe reservado (receita de bolo?). Depois, remova o cartão micro-sd e conecte uma fonte 5v (a do meu Galileo é 1.5A, mas 1A deve ser suficiente), aguarde entre 15 e 20 segundos. Após, conecte um cabo micro-usb na porta usb-client da Intel Galileo e conecte-a ao computador. Entre no diretório que você descomprimiu e execute a IDE do Arduino. TEM que ser essa porque só ela tem a opção de Firmware Update no menu help, apesar de eu ter adicionado suporte ao Galileo na IDE mais nova, o menu help não disponibilizou essa opção. O processo deve levar longos 5 minutos e um aviso será exibido informando a necessidade de alimentação externa e que em hipótese alguma a board deve ser desligada. Ao final (se tudo der certo) uma mensagem será exibida com o status da atualização, nada excepcional.

Linux para Intel Galileo

Baixe o Yocto através desse link. Descomprimi essa imagem e então fiz dd para o cartão que já continha o sistema de arquivos FAT32 (mas que é sobrescrito pelo dd de qualquer modo). A imagem descomprimida tem 1.4GB (!) e deve levar um tempinho até escrever no cartão. Vou passar o procedimento que adotei, mas se você não souber fazer, tiver dúvidas ou não entender qualquer coisa, melhor pedir ajuda pra alguém:

mkfs.vfat -F32 /dev/DEVICE_DO_CARTAO_SD sudo dd if=if=iot-devkit-1.5-i586-galileo of=/dev/DEVICE_DO_CARTAO_SD bs=3M conv=fsync

Isto é, se seu dispositivo DEVICE_DO_CARTAO_SD for sdb, substitua por sdb. Se for mmcblk0, substitua por mmcblk0 e assim por diante.
Fazendo o boot do Linux na Galileo

Ao término do processo dd, retire o cartão sd do computador e coloque-o no Galileo, realimente-o conectado à sua rede e em um minutinho, vasculhe pelo IPs da rede para descobrí-lo. Eu costumo olhar na interface de gerenciamento do roteador os clients conectados, mas excepcionalmente hoje estava com preguiça de levantar e preferi configurar um servidor DHCP no meu notebook escutando na eth0. Só isso no dhcpd.conf:

subnet 10.0.0.0 netmask 255.0.0.0 {
  range 10.0.0.10 10.0.0.11;
  option routers 10.0.0.2;
}

Depois do boot da Galileo, digite 'arp' no console para ver o IP que a board pegou:

KGB ~ # arp
Address                  HWtype  HWaddress           Flags Mask            Iface
192.168.1.230            ether   14:30:c6:6f:1b:87   C                     wlan0
192.168.1.232            ether   40:78:6a:22:2a:f2   C                     wlan0
192.168.1.250            ether   d0:66:7b:d1:d1:d4   C                     wlan0
192.168.1.1              ether   b0:48:7a:b4:e3:30   C                     wlan0
10.0.0.10                ether   98:4f:ee:01:41:bc   C                     eth0

A galileo pegou o 10.0.0.10. Como o IP veio do meu servidor, poderia ver nos logs ou no dhcp.leases, mas não importa; isso não é uma aula de Linux. Seguindo.

Agora basta fazer o acesso por ssh no IP que pegou para desfrutar do sistema.

Se quiser manipular o GPIO pelo Linux, veja esse post sobre a board Carambola. O processo de manipulação do GPIO é o mesmo.

Se você quiser acessar o shell do Linux através da serial, você tem duas opções; uma é digitar os comandos pelo terminal que você conectou via ssh:

cp /etc/inittab /etc/inittab.bak
sed -i 's/S:2345/S0:2345/g' /etc/inittab
sed -i 's/ttyS1/ttyGS0/g' /etc/inittab
sed -i 's/grst/#grst/g' /etc/inittab
sed -i 's/clld/#clld/g' /etc/inittab
kill -SIGHUP 1 # tchau, tchau...

e A outra maneira é subir um sketch:

void setup() 
{
  system("cp /etc/inittab /etc/inittab.bak");  // Back up inittab
  // Replace all "S:2345" with "S0:2345"'s (switching serial ports):
  system("sed -i 's/S:2345/S0:2345/g' /etc/inittab");
  // Replace all "ttyS1" with "ttyGS0"'s (switching serial ports):
  system("sed -i 's/ttyS1/ttyGS0/g' /etc/inittab");
  // Replace all "grst" with "#grst"'s to comment that line out:
  system("sed -i 's/grst/#grst/g' /etc/inittab");
  // Replace all "clld" with "#clld"'s to comment that line out:
  system("sed -i 's/clld/#clld/g' /etc/inittab");
  system("kill -SIGHUP 1");
}
void loop() 
{

}

Após isso, você poderá se conectar a 115200 pelo terminal serial, mas não poderá mais subir sketches até que a modificação seja desfeita:

rm /sketch/sketch.elf
cp /etc/inittab.bak /etc/inittab
kill -SIGHUP 1

Agora é só brincar com os recursos da board. Falando de Internet das Coisas, o Broker Mosquitto vem por padrão nessa imagem, bastando fazer a configuração, caso deseje utilizá-lo. Se não conhece o MQTT ou se quer saber como fazer uma comunicação entre Broker e client, veja esse post de uma comunicação em Lua e esse para configurar um Broker com Mosquitto.

Inscreva-se no nosso canal Manual do Maker Brasil no YouTube.

Próximo post a caminho!