Sou fã confesso da Beagleboard. Na minha opinião, é hoje a melhor plataforma para se aprender Linux embarcado e trabalhar com software livre. Muitos projetos, boa documentação e custo acessível.

Já escrevi aqui alguns artigos sobre esta plataforma, e já trabalhei também em alguns projetos comerciais baseados nela. E quando fiquei sabendo do lançamento da Beaglebone, não pensei duas vezes em comprar. Um mês e meio depois (sim, ela ficou um bom tempo presa na alfândega!), cá estou eu e o Arthur com nosso novo brinquedinho!



A Beaglebone, assim como a Beagleboard, também é um projeto de hardware aberto, porém com um design um pouco mais simples, e consequentemente mais barato. É uma plataforma de prototipação, e nesse sentido tem objetivos bem parecidos com o Arduino, já que usa o conceito de shields (no caso da Beaglebone veremos que estas placas de expansão chamam-se capes). Mas ela não veio para substituir ou competir com o Arduino, muito menos com a Beagleboard ou com a Raspberry Pi — falaremos sobre isso mais adiante. Por hora, que tal darmos olhada no hardware?

HARDWARE

A Beaglebone é baseada no processador AM3359, um ARM Cortex-A8 da Texas Instruments que roda em até 720MHz, e possui 32K de cache L1, 256K de cache L2, 176K de ROM e 64K de RAM interna. Além disso, possui acelerador gráfico 3D, controlador LCD de 24 bits e controlador para a interface touchscreen.



A placa vem com 256MB de SDRAM, e assim como a Beagleboard-xM, não possui memória flash. Você precisa usar o cartão SD como unidade de armazenamento. Pode ser alimentada tanto por uma fonte externa quanto pela porta USB device. Esta mesma porta USB serve também de conexão serial (console), graças ao adaptador USB->Serial/JTAG incluido no design do hardware. Possui uma E2PROM de 32KB ligada ao barramento I2C, além das interfaces USB host, Ethernet, cartão SD/MMC e 4 leds que podem ser controlados pelo usuário.



O restante das interfaces de I/O estão disponíveis em 2 conectores de expansão de 46 pinos que podem fornecer diferentes conexões e barramentos como SPI, I2C, GPIO, LCD, HDMI, VGA, MMC, RS232, CAN, A/D, carregador de bateria, etc!

São nesses conectores que você pode plugar as placas de expansão, chamadas de capes. Cada beaglebone aceita até 4 capes, e cada cape deve ter uma E2PROM endereçável ligada ao barramento I2C, que vai ajudar o sistema operacional a identificá-la e configurar os I/Os de acordo.

Cape com saídas de áudio e vídeo

No momento em que escrevo este artigo, o preço da Beaglebone varia de $79 a $89 (FOB), dependendo do distribuidor e se você quer adquirir apenas a placa ou o kit completo. Convertendo para nossa moeda, e incluindo frete e impostos, deve sair em torno de R$350,00. A lista oficial de distribuidores encontra-se em http://beagleboard.org/buy.

O kit completo vem com a placa, um cabo USB e um cartão SD de 4G com a documentação e uma imagem do Angstrom pré-instalada.

E por falar em imagem, que tal colocar esta plaquinha pra funcionar?

SOFTWARE

Alimente a Beaglebone diretamente com o cabo USB, ou ligue uma fonte externa de 5V. O led de Power irá acender, e os leds USER0 e USER1 começarão a piscar. A Beaglebone será identificada na sua máquina de desenvolvimento como um dispositivo de armazenamento (como se fosse um pendrive). Você verá um dispositivo chamado BEAGLE_BONE com um monte de arquivos, incluindo as imagens do bootloader e do kernel, documentação e drivers para sistemas operacionais menos evoluidos :)

O primeiro passo é abrir o arquivo README.htm no seu navegador e dar uma lida. Este arquivo contém algumas orientações gerais sobre o funcionamento da Beaglebone.

Neste momento, a distribuição Angstrom que vem com a placa já esta rodando. E você pode acessá-la de algumas formas.

ACESSANDO VIA CONSOLE

Para acessar via console no Linux, você vai precisar inserir o modulo ftdi_sio, conforme abaixo:

$ sudo modprobe ftdi_sio vendor=0x0403 product=0xa6d0

Serão criados dois dispositivos tty (no meu caso foram criados o ttyUSB0 e o ttyUSB1). O segundo (ttyUSB1) é a console. Configure sua aplicação de terminal favorita com 115200 8N1 e teste o acesso à console:

U-Boot SPL 2011.09-00000-gf63b270-dirty (Nov 14 2011 - 10:37:14)
Texas Instruments Revision detection unimplemented
OMAP SD/MMC: 0
reading u-boot.img
reading u-boot.img
 
U-Boot 2011.09-00000-gf63b270-dirty (Nov 14 2011 - 10:37:14)
 
...
 
.---O---.                                           
|       |                  .-.           o o        
|   |   |-----.-----.-----.| |   .----..-----.-----.
|       |     | __  |  ---'| '--.|  .-'|     |     |
|   |   |  |  |     |---  ||  --'|  |  |  '  | | | |
'---'---'--'--'--.  |-----''----''--'  '-----'-'-'-'
                -'  |
                '---'
 
The Angstrom Distribution beaglebone ttyO0
 
Angstrom v2011.10-core - Kernel 3.1.0+
 
beaglebone login:

O usuário é root e a senha vazia.

Se você tiver problemas, ou estiver usando outro sistema operacional, o arquivo README.htm mencionado mais acima possui algumas instruções adicionais que podem ajudá-lo.

CONECTANDO VIA REDE

A Beaglebone tem um cliente DHCP rodando, então quando você ligá-la na sua rede (supondo-se que sua rede tenha um servidor DHCP), ela irá pegar um IP automaticamente.

Você pode consultar o IP atribuído à Beaglebone acessando-a via console, verificando o arquivo info.txt ou listando os logs do seu servidor DHCP.

Com a conexão de rede funcionando, você consegue acessar a Beaglebone por SSH (usuário root e sem senha):

$ ssh root@192.168.1.107
The authenticity of host '192.168.1.107 (192.168.1.107)' can't be established.
RSA key fingerprint is d6:67:cf:08:d0:87:12:d9:12:c9:37:d9:81:bd:aa:db.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.1.107' (RSA) to the list of known hosts.
root@192.168.1.107's password:
root@beaglebone:~#

A Beaglebone tem um servidor rodando na porta 80 que disponibiliza uma apresentação do projeto. Supondo que o IP da Beaglebone seja “192.168.0.7″, você consegue acessar este servidor simplesmente digitando no seu navegador “http:/192.168.0.7/”:


A Beaglebone tem também um outro servidor na porta 443 provendo acesso à console do equipamento via SSH de dentro do seu navegador! Supondo novamente que o IP da Beaglebone seja “192.168.0.7″, você consegue acessar este servidor digitando no seu navegador “https:/192.168.0.7/”. Obs: a Beaglebone usa o GateOne, um terminal e cliente SSH desenvolvido em HTML5. Portanto, você precisa de um navegador com suporte à HTML5.



Mas o mais legal mesmo é a IDE embarcada no dispositivo e que pode ser acessada pelo navegador na porta 3000. Supondo mais uma vez que o IP da Beaglebone seja “192.168.0.7″, você consegue acessar esta IDE digitando no seu navegador “http:/192.168.0.7:3000“


Esta IDE embarcada na Beaglebone é a Cloud9 IDE, uma interface que roda no seu navegador, e que possibilita escrever, executar e debugar aplicações escritas em JavaScript e baseadas em um framework chamado node.js.

O conceito é bem parecido com o do projeto mbed que recebeu um artigo um tempo atrás. Em ambos os projetos, a IDE roda no navegador. No caso do mbed, a IDE roda em um servidor na Internet. E no caso da Beaglebone, a IDE roda dentro dela mesmo!

E o que é esse tal de node.js? Segundo a página do projeto, o node.js é uma plataforma que roda em cima do V8 (engine de JavaScript do Google) desenvolvida para se construir aplicações de rede rápidas e escaláveis. Na prática, você escreve programas em JavaScript que são interpretados e executados dentro da Beaglebone por uma aplicação chamada “node”. Ou seja, você trabalha com uma linguagem de script, mais amigável e com bibliotecas prontas para interfacear com o hardware e com o sistema operacional.

Por exemplo, esta é uma aplicação escrita em node.js que faz o led USER3 da Beaglebone piscar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

var bb = require('./bonescript');
 
var ledPin = bone.P8_3;
var ledPin2 = bone.USR3;
 
setup = function() {
    pinMode(ledPin, OUTPUT);
    pinMode(ledPin2, OUTPUT);
};
 
loop = function() {
    digitalWrite(ledPin, HIGH);
    digitalWrite(ledPin2, HIGH);
    delay(1000);
    digitalWrite(ledPin, LOW);
    digitalWrite(ledPin2, LOW);
    delay(1000);
};
 
bb.run();

BEAGLEBONE X ARDUINO

A Beaglebone veio para preencher uma lacuna existente em desenvolvimento rápido e prototipagem para soluções high-end com Linux. Por esse motivo, não tem como deixar de fazer uma comparação com o Arduino. Ambos foram projetados com o conceito de expansão para facilitar a prototipagem: o Arduino com seus shields e a Beaglebone com seus capes. Ambos também possuem um ambiente de desenvolvimento que roda em qualquer SO, linguagem mais user-friendly, bibliotecas prontas, etc.

Mas não creio que seja uma questão de concorrência. O Arduino continuará sendo usado para acender leds, controlar motores e fazer seu robô andar. Agora, se você precisar de um sistema de reconhecimento facial dentro do seu robô, é aí que pode entrar a Beaglebone.

BEAGLEBONE X BEAGLEBOARD-XM

De forma alguma a Beaglebone é uma evolução da Beagleboard-xM. Muito pelo contrário, o hardware da Beagleboard-xM é melhor. Eles apenas são projetos com conceitos diferentes. Se você quer mais processamento, memória, portas USB e conexão de vídeo, vai de Beagleboard-xM. Já se o que você quer é um hardware fácil de expandir e de baixo custo, vai de Beaglebone.

BEAGLEBOARD X RASPBERRY PI

Também não faz sentido a comparação. O objetivo do projeto Raspberry Pi é o de ser um PC de baixo custo. Tá certo que, devido ao seu baixíssimo custo ($25 na versão normal e $35 na versão com Ethernet), muita gente vai querer tirar uma casquinha e até usar em algum projeto. Ou seja, se o que você precisa é de algo próximo à um computador pessoal (porta USB, saídas de áudio e vídeo) e de baixissimo custo, você pode pensar em usar a Raspberry Pi. Se você quer algo com mais capacidade de processamento, com diferentes interfaces de I/O e capacidade de expansão, pode pensar em usar a Beaglebone.

O negócio agora é esperar a evolução do projeto, as placas de expansão que serão lançadas (ainda não me acostumei com o nome “capes”), e se o uso do framework node.js em Linux embarcado vai se popularizar.

Enquanto isso, diz aí: o que você achou da Beaglebone? Tem intenção de comprá-la para usar em algum projeto?

Um abraço,

Sergio Prado

Sem posts relacionados.

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Introduzindo a Beaglebone.

O kit de desenvolvimento LPC3250 da Embedded Artists vem equipado com o microcontrolador LPC3250 da NXP, e pode ser uma boa escolha se você quer boa performance, alto nível de integração de periféricos e baixo consumo.

Se sua aplicação precisa de uma capacidade de processamento maior do que a oferecida pelas CPUs ARM Cortex-M3, com necessidades de display gráfico e conectividade, mas não quer uma solução tão high-end como as linhas i.MX da Freescale ou Sitara da TI, talvez o LPC3250 seja o que você procura.

O kit é composto basicamente por uma placa com CPU e memória RAM/Flash (LPC3250 OEM Board) conectada à uma placa-base (QVGA Base Board), com o display e um conjunto de periféricos para acesso.

O microcontrolador LPC3250 é um ARM9 rodando à 266MHz com 256kB de SRAM, interface para flash NAND e barramento para SDRAM, Ethernet MAC e um controlador de display LCD integrados, além de diversas interfaces de comunicação como USB, UART, I2C, SPI, I2S, PWM, ADC, etc.

O kit vêm com 128MB de flash NAND, 4MB de flash NOR e 64MB de SDRAM. Pode ser alimentado por USB ou uma fonte externa de 9-15V. Possui interfaces Ethernet, USB host/OTG, cartão SD/MMC, display LCD de 3.2″, JTAG, RS232, IrDA, acelerômetro, E2PROM, botões, leds e conectores para expansão de I/O.

O manual do usuário pode ser baixado aqui e o datasheet aqui.

O kit pode ser adquirido no site da Embedded Artists por $340 FOB (no momento em que escrevo este artigo), ou em um de seus distribuidores como a Digi-Key, a Future Electronics e a Mouser. No Brasil, a Microgenios é a distribuidora oficial da Embedded Artists.

LINUX

Com MMU e boa capacidade de memória (Flash e RAM), conectividade e interface com displays gráficos, o kit é uma boa plataforma para se trabalhar com Linux.

A comunidade Linux para os microcontroladores da NXP gira em torno do site http://www.lpclinux.com, com seções de download, tutoriais, blogs, forums, etc.

PROCESSO DE BOOT

O microcontrolador LPC3250 possui uma ROM interna de 32K com um código de boot que é executado sempre que você liga o equipamento. Este código de boot procura por um bootloader em 4 diferentes fontes: UART, SPI, NOR e NAND.

Quando você liga o equipamento, este código de boot em ROM verifica a entrada SERVICE (GPI_1) do microcontrolador. Se esta entrada estiver em nível baixo, o codigo de boot inicia um processo de recuperação para baixar um programa pela UART e carregá-lo para a SRAM. Se esta entrada estiver em nível alto, ele irá procurar por um bootloader nas seguintes interfaces, nesta ordem: SPI, NOR e NAND. Se ele encontrar, irá carregar os primeiros 54kB para a SRAM.

Este código carregado para a SRAM é o bootloader de 1o. estágio, chamado de Kickstarter, responsável basicamente por carregar e iniciar um bootloader de 2o. estágio, o S1L. Este bootloader de 2o. estágio é o responsável por inicializar o hardware (GPIO, clock, SDRAM, etc) e carregar o bootloader de 3o. estágio, o U-Boot. Ufa!

Daí é o processo normal de qualquer sistema Linux embarcado, o U-Boot carrega o kernel e então temos nosso sistema Linux rodando no kit.

USANDO O KIT

Para usar o kit, basta alimentá-lo com o cabo USB, conforme figura abaixo:

Você só vai precisar de uma fonte externa se for ligar dispositivos de consumo alto no barramento USB.

Como a placa possui o chip FT232 da FTDI, ao mesmo tempo que o cabo USB serve para alimentar o kit, ele será sua conexão serial (console) com o equipamento!

Configure seu programa de comunicação serial preferido com 115200-8N1, ligue o kit na sua máquina de desenvolvimento pelo cabo USB, e veja o menu do bootloader de 2o. estágio (S1L):

Embedded Artist 3250 Board (S1L 2.0)
Build date: Nov 23 2010 13:21:19
 
EA3250#

Com este bootloader você é capaz de bootar do cartão SD, da UART ou da NAND Flash. Mas é claro que você vai querer bootar o Linux, não é verdade? Então você vai precisar gravar o U-Boot na flash NAND.

Você pode baixar o u-boot daqui, renomeá-lo para u-boot.bin e salvá-lo em um cartão SD.

Coloque o cartão SD no kit, reinicie-o e na linha de comandos do bootloader S1L, carregue o U-Boot do cartão SD para a RAM:

EA3250# load blk u-boot.bin raw 0x83fa0000

Salve na flash:

EA3250# nsave

E configure o bootloader S1L para automaticamente carregar o U-Boot no boot do equipamento:

EA3250# aboot flash raw 0x83fa0000

Configure também um delay de 2 segundos no boot do S1L:

EA3250# prompt EA3250# 2

Reinicie e pronto! Você receberá o prompt do U-Boot no terminal:

Embedded Artist 3250 Board (S1L 2.0)
Build date: Nov 23 2010 13:21:19
Autoboot in progress, press any key to stop
 
U-Boot 2009.03-rc1 (Sep 28 2009 - 09:38:20)
 
DRAM:  64 MB
NAND:  128 MiB
*** Warning - bad CRC or NAND, using default environment
 
In:    serial
Out:   serial
Err:   serial
Hit any key to stop autoboot:  0
uboot#

TREINAMENTO

Este é o kit que utilizarei nas minhas primeiras seções do treinamento de Linux embarcado. Os kits foram gentilmente cedidos pela NXP para a realização do treinamento.

Busquei desenvolver uma metodologia de ensino de forma que as atividades de laboratório fossem independentes de hardware. Nada de receitas de bolo. O que você aprender com este kit, poderá aplicar em qualquer outro hardware com suporte à Linux. Mas espero que possamos nos divertir bastante com este kit, desenvolver alguns projetos legais durante (e depois) do treinamento, e claro, aprender Linux embarcado!

Para quem já se inscreveu, vejo vocês lá!

Um abraço!

Sergio Prado

Posts relacionados:

1. Kit de desenvolvimento FriendlyARM mini2440
2. Linux embarcado com o SAM9M10 da Atmel

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Kit de desenvolvimento LPC3250 da Embedded Artists.

Nem só de Beagleboard e FriendlyARM vive o mercado de soluções para sistemas embarcados com Linux. Existem outras opções de fabricantes como NXP, Freescale e Atmel.

Nas últimas semanas, tive a oportunidade de trabalhar com o kit AT91SAM9M10-G45-EK da Atmel. E como não existe muita documentação na Internet sobre este kit e também sobre o uso de produtos da Atmel com Linux embarcado, resolvi documentar minhas impressões neste post, e quem sabe ajudar outras pessoas com as mesmas necessidades.

Não é um kit que recomendo para quem quer estudar Linux embarcado. No momento que escrevo este post, você pode comprar o kit pela “bagatela” de 750 dolares (FOB). Mas é uma opção interessante para avaliar a CPU em projetos comerciais, e para quem esta acostumado a trabalhar com produtos da Atmel.

HARDWARE

O AT91SAM9M10-G45-EK é uma plataforma de avaliação para a CPU AT91SAM9M10 da Atmel, um ARM9 de 400MHz. É uma CPU voltada à aplicações multimedia que combina interfaces de conectividade com playback de vídeo. A CPU possui um decodificador de vídeo por hardware com suporte à H.264, MPEG-4, MPEG-2, VC-1 e H.263. 

O kit tem 128M de RAM DDR2 e 256M de flash NAND (o uso de flash NOR é opcional). Vem com um display LCD TFT touch de 4.3″, e possui diversas interfaces como USB device/host, Ethernet, UART, cartão SD/MMC, composite video, áudio, câmera, botões, leds, etc.

Mais informações sobre o kit você pode encontrar no site da Atmel.

PROCESSO DE BOOT

Sempre que começo a trabalhar com uma nova plataforma de hardware, procuro entender o processo de boot da CPU.

Este kit é capaz de trabalhar com 4 diferentes dispositivos de boot:

• NAND Flash
• SDCard
• DataFlash® 
• Serial DataFlash

E a sequência de boot acontece em algumas etapas:

A CPU possui um código em ROM que é executado no boot do equipamento. Este código verifica o pino de entrada BMS. Se não estiver setado, tentar bootar pela flash NOR. Se estiver setado, verifica a disponibilidade das interfaces SDCard, flash NAND e Dataflash, nesta ordem. Se encontrar uma destas interfaces disponíveis, carrega os primeiros 4KB para a SRAM e executa. Se não encontrar, cai em um código de boot chamado SAM-BA. Este é um software de recovery, que você pode usar para se comunicar com seu PC via USB para escrever na flash.

O uso do SAM-BA é uma estratégia interessante, já que você não tem uma flash NOR com um bootloader para gravar o U-Boot na NAND. Você pode então usar o SAM-BA para gravar o U-Boot na flash NAND, e a partir daí usar o U-Boot para gravar o kernel e o rootfs.

Portanto, se você apagar “acidentalmente” o bootloader da NAND, vai precisar do SAM-BA. A documentação do procedimento de recuperação usando o SAM-BA pode ser acessado aqui. E se você tiver problemas em usar a aplicação SAM-BA para Linux, como eu tive, dá uma lida neste artigo aqui.

Uma vez que a CPU identificou a disponibilidade de um dos dispositivos de boot, a sequência continua conforme a imagem abaixo:

Os 4KB de código que o ROM code da CPU carregou para a SRAM no boot é o AT91BootStrap, um bootloader da Atmel. Sua responsabilidade é basicamente inicializar a CPU e a SDRAM, e carregar um bootloader de 3o. nível, que no nosso caso é o U-Boot. A partir daí, o processo é o mesmo de qualquer sistema com Linux embarcado, sendo o U-Boot o responsável por carregar o kernel do Linux para a memória e executá-lo.

SUPORTE AO LINUX

O kit vem com uma versão demo da distribuição Angstrom, que pode ser baixada aqui.

Toda a documentação sobre o uso de Linux neste kit pode ser encontrada no site da Atmel. É um ponto de partida para quem esta iniciando os trabalhos com Linux nesta plataforma. Mas como não é uma plataforma muito difundida entre hobbystas e entusiastas Linux (quando comparamos com a Beagleboard, por exemplo) existem poucos fóruns e sites com informações à respeito.

Foi utilizada a versão 1.3.4 do U-Boot para o port, bastando aplicar os patches disponíveis aqui. A versão 2.6.30 do kernel do Linux foi utilizada para desenvolver o BSP para esta plataforma, e os patches estão disponíveis aqui.

GERANDO UMA DISTRIBUIÇÃO LINUX DO ZERO

Com o Buildroot, é possível gerar uma distribuição Linux embarcada do zero para este kit em menos de 1 hora.

Escrevi um documento com os procedimentos que pode ser baixado aqui.

GRAVANDO O LINUX NA FLASH NAND

Como o U-Boot não tem suporte à interface SD/MMC, a única forma dele carregar o kernel e o rootfs é via interface Ethernet.

Portanto, podemos usar o TFTP para transferir as imagens para o U-Boot para gravá-las na flash.

Você vai precisar do servidor TFTP configurado na sua máquina de desenvolvimento. Se não tiver, este artigo da Timesys explica como fazer.

Com o TFTP configurado, copie as imagens do kernel (uImage) e do rootfs (rootfs.jffs2) para o diretório do TFTP, coloque o kit em rede com a máquina de desenvolvimento, ligue-o e entre no menu do U-Boot.

Primeiro, configure a rede (altere os endereços IP conforme a configuração da sua rede):

# setenv ipaddr 192.168.0.100
# setenv serverip 192.168.0.1
# saveenv

Você pode verificar se a rede esta configurando através do comando ping:

# ping 192.168.0.1

Para gravar o o kernel:

# tftp 0x72200000 uImage
# nand erase 0x00200000 0x00200000
# nand write.e 0x72200000 0x00200000 0x00200000

Para gravar o rootfs:

# tftp 0x72200000 rootfs.jffs2
# nand erase 0x00400000 0x03C00000
# nand write.jffs2 0x72200000 0x00400000 0x180000

Por último, configure o U-Boot para iniciar o Linux pela flash NAND:

# setenv bootargs 'mem=64M console=ttyS0,115200 mtdparts=atmel_nand:4M(bootstrap/uboot/kernel)ro,60M(rootfs),-(data) root=/dev/mtdblock1 rw rootfstype=jffs2'
# setenv bootcmd 'nand read.e 0x72200000 0x00200000 0x1ad8f0; bootm 0x72200000'
# saveenv

Dica final: sempre que possível, nunca se prenda a soluções fechadas/proprietárias.

A Atmel fornece a ferramenta SAM-BA, que além de poder ser usada como ferramenta para recuperar o bootloader da NAND, pode também ser usada para gravar o kernel e o rootfs na flash ou no cartão SD.

Mas eu prefiro soluções padronizadas e abertas como o TFTP e o U-Boot. Por quê? Porque quando eu migrar para produtos de outros fabricantes como a Texas, a Freescale, ou a NXP, já terei o caminho das pedras na cabeça. Suporte soluções open source. Sempre!

Um abraço,

Sergio Prado

Sem posts relacionados.

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Linux embarcado com o SAM9M10 da Atmel.

A BeagleBoard é um projeto desenvolvido pela Texas Instruments em conjunto com a Digi-Key com os objetivos de demonstrar o uso do system-on-a-chip OMAP3530 e servir de plataforma de aprendizado em sistemas embarcados através do modelo de desenvolvimento open source. Enquanto que a TI é a responsável pelo projeto, a Digi-key seria a responsável pela distribuição.

A plataforma é totalmente aberta, liberada sob a licença Creative Commons SharedAlike. Com já mais de 2 anos de existência, ela tem cumprido bem seu objetivo de ensinar open hardware e open software no mundo inteiro. A página do projeto pode ser encontrada em http://beagleboard.org/.

BeagleBoard: Do tamanho da palma da sua mão

Enquanto escrevo este artigo, existem cerca de 210 projetos desenvolvidos pela comunidade! Estes projetos incluem alguns portes do sistema operacional Android, controlador de câmera digital, sistema de segurança residencial, sistema multimedia para veículos, streaming de video, media center, diversos tipos de robôs, etc. Mais um indicativo das mudanças sociais e econômicas trazidas pelo movimento open source. Uma lista com todos os projetos pode ser acessada em http://beagleboard.org/project. Alguns vídeos com projetos interessantes podem ser encontrados aqui, aqui e aqui.

Das palavras de um dos responsáveis pelo projeto, Jason Kridner:

“The Beagle Board is intended for those wanting to learn about building embedded systems and [who] don’t need all of the support or costs associated with the typical development platform. Once you are done experimenting and need a silicon evaluation platform that will help you make a product, platforms with software compatibility are available.”

HARDWARE

A placa é pequena, medindo aproximadamente 7,5 x 7,5 cm, e já passou por algumas revisões desde seu lançamento. A que tenho em mãos é a Rev C4. 

Interfaces disponíveis na BeagleBoard

Conforme já mencionei, a BeagleBoard é baseada no system-on-a-chip OMAP3530 da TI, um dos primeiros SOCs baseados no núcleo ARM Cortex-A8. Trabalhando a 720MHz, ainda possui integrado um DSP de 430MHz e um acelerador gráfico 2D/3D, que junto com uma placa gráfica onboard que provê saídas DVI e S-Video, transforma o kit em uma plataforma ideal para aplicações multimedia, com capacidade para reproduzir vídeos em HD a 720p.

Por dentro do OMAP3530

Esta revisão possui 256MB de memória flash NAND e 256MB de DDR SDRAM, que junto com o OMAP3530, são montados na placa usando a técnica de Package-on-Package, onde um chip é montado sob o outro:

Package-on-Package

Interfaces de I/O também não faltam: RS232, USB 2.0 e USB On-the-go, cartão de memória SD/MMC, Audio In/Out (Stereo), JTAG, LEDs e botões, além de um conector para usar um display LCD e outro para placas de expansão com diversas interfaces disponíveis como GPIO, PWM, I2C, I2S, SPI e SD/MMC. A alimentação pode ser feita por uma entrada de 5V ou pela porta USB. Uma referência completa do hardware pode ser encontrada aqui. São 180 páginas de muita informação!

COMPARANDO COM A MINI2440

Quem acompanha meu blog sabe que gosto bastante do kit FriendlyARM mini2440 como ferramenta de aprendizado, principalmente para aprender sobre Linux embarcado. Mas qual é melhor, a Beagleboard ou a mini2440? A resposta: depende!

Sob o ponto de vista do hardware, a Beagleboard é muito mais poderosa. Sua capacidade de vídeo e a existência de um DSP tornam possiveis aplicações multimedia que não seriam possíveis na mini2440. Por outro lado, a minha revisão da Beagle Rev C4 não possui interface Ethernet. Se eu precisar de uma interface Ethernet, precisarei usar um dongle USB. Já na mini2440 temos uma porta Ethernet por padrão. Esta deficiência da BeagleBoard é resolvida na sua última revisão, a BeagleBoard-xM, que além da interface Ethernet, trabalha a 1GHz!

Outra desvantagem da Beagle com relação ao hardware é a ausência de um display LCD. A idéia aqui é usar as saídas DVI ou S-Video e plugá-la diretamente em um monitor ou televisor. Mas nada impede você de comprar um display LCD e conectar nos pinos de I/O disponíveis na Beagle. Já existem alguns projetos que fazem isso. Você só precisará comprar o display separadamente.

Por outro lado, a BeagleBoard, por apostar no formato open source, foi muito mais competente em documentar o projeto e montar uma comunidade onde as pessoas publicam seus projetos e compartilham informações.

De qualquer forma, os dois kits suprem bem a necessidade de uma ferramenta para aprendizado em sistemas embarcados. Escolha o que melhor couber no seu bolso.

ONDE COMPRAR

A BeagleBoard pode ser adquirida em alguns sites na internet, incluindo a Digi-Key e a Mouser. No site do projeto tem uma lista completa de distribuidores. Na Special Computing você também consegue comprar, além da placa, os cabos, fontes e até um case de acrílico para colocar a placa enquanto estuda ou desenvolve seu protótipo.

O preço atual é de $125.00, mais frete e impostos. Mas esse valor é só pela placa. Você vai precisar de um cabo adaptador serial IDC10 -> DB9 macho igual este aqui para a console. Pode precisar também de um cabo HDMI tipo A -> DVI, se quiser ligar a placa em um monitor, e de uma fonte de 5V se precisar ligar muitos periféricos na placa e achar que a alimentação via USB não será suficiente para “aguentar o tranco”.

PRIMEIROS SINAIS DE VIDA

Estes são os primeiros sinais de vida da BeagleBoard, que podemos visualizar na console:

Texas Instruments X-Loader 1.4.2 (Feb 19 2009 - 12:01:24)
Loading u-boot.bin from nand
 
U-Boot 2009.11-rc1-00601-g3aa4b51 (Jan 05 2010 - 20:56:38)
 
OMAP3530-GP ES3.1, CPU-OPP2 L3-165MHz
OMAP3 Beagle board + LPDDR/NAND
I2C:   ready
DRAM:  256 MB
NAND:  256 MiB
*** Warning - bad CRC or NAND, using default environment
 
In:    serial
Out:   serial
Err:   serial
Board revision C4
Die ID #7e1c000400000000040398da1402400e
Hit any key to stop autoboot:  0
No MMC card found
Booting from nand ...
 
NAND read: device 0 offset 0x280000, size 0x400000
 4194304 bytes read: OK
Wrong Image Format for bootm command
ERROR: can't get kernel image!
OMAP3 beagleboard.org #

Ela vem de fábrica com o X-Loader e o U-Boot instalados na NAND. O processo de boot acontece em 3 estágios:

• 1o. estágio: Software residente em ROM
• 2o. estágio: X-Loader
• 3o. estágio: U-Boot

No fim, o U-Boot tentar carregar o kernel do Linux, e como não encontra a imagem, cai no prompt. Vamos tentar listar as partições da NAND:

OMAP3 beagleboard.org # mtdparts
mtdparts variable not set, see 'help mtdparts'
no partitions defined
 
defaults:
mtdids  : nand0=nand
mtdparts: mtdpart' - try 'help'loader),1920k(u-boot),128k(u-boot-env),4m(kernel),-(fs)

Veja que a tabela de partições encontra-se inicialmente vazia. Podemos configurar as partições padrão com o comando abaixo:

OMAP3 beagleboard.org # mtdparts default

E então podemos ver as partições:

OMAP3 beagleboard.org # mtdparts
 
device nand0 <nand>, # parts = 5
 #: name                size            offset          mask_flags
 0: x-loader            0x00080000      0x00000000      0
 1: u-boot              0x001e0000      0x00080000      0
 2: u-boot-env          0x00020000      0x00260000      0
 3: kernel              0x00400000      0x00280000      0
 4: fs                  0x0f980000      0x00680000      0
 
active partition: nand0,0 - (x-loader) 0x00080000 @ 0x00000000</nand>

Agora a NAND esta pronta para gravarmos o kernel e o rootfs. Que tal um pouco de Android no próximo post? Até lá!

Abraços,

Sergio Prado

Posts relacionados:

1. Open Source Hardware
2. Ferramentas open-source para pic

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em BeagleBoard — O cachorrinho open-source.

Recebi recentemente da NXP o kit mbed, conforme já havia escrito neste artigo aqui. E após algumas horas “brincando” com ele, minhas impressões são muito boas. O kit é realmente intuitivo e fácil de usar, perfeito para quem quer prototipar algo rapidamente e ver o negócio funcionando. Vamos então dar uma olhada mais de perto neste kit.

O HARDWARE

O kit usa o LCP1768 da NXP, um ARM Cortex-M3 com 512K de flash e 32K de RAM, voltado principalmente para aplicações mais complexas com requisitos de tempo real. A CPU roda a 96MHz, com um pipeline de 3 estágios e arquitetura Harvard (barramento separado para código e dados). Além disso, possui também um barramento separado para os periféricos. E por falar em periféricos, a lista é grande. A começar por 70 I/Os configuráveis, 4 UARTs, SPI, I2C, CAN 2.0, USB 2.0 Device/Host e Ethernet MAC. A placa em si é pequena, possui 1 led de status, 4 leds de uso geral, um botão de reset e uma porta serial que pode ser emulada através da interface USB.

Interfaces disponíveis no kit mbed

O PROJETO

A plataforma mbed (www.mbed.org) foi iniciada por dois funcionários da ARM, que depois assumiu o projeto em parceria com a NXP. Seu principal objetivo é prover um ambiente de prototipagem rápida. Você tem uma idéia, como colocar isso em prática da forma mais rápida possível? Não estamos falando aqui de desenvolver o produto final, e sim de experimentar, de validar uma idéia. O kit atinge muito bem este objetivo, por 4 principais motivos.

1) A placa foi desenvolvida no formato DIP de 40 pinos. Isso significa que você consegue espetá-la facilmente numa protoboard, adicionar alguns periféricos e voilá: hardware pronto para testes!

Kit mbed visto por baixo

2) O ambiente de desenvolvimento (editor de texto, compilador, arquivos do projeto) é todo baseado em computação na nuvem. Você faz tudo pelo seu navegador preferido, dentro do seu sistema operacional predileto. Que bom que não precisei reiniciar no Window$ para testar o kit! :) E não precisa instalar nada mesmo. Todo o processo de programação, compilação e gravação é transparente para o desenvolvedor.

Ambiente de desenvolvimento dentro do navegador Chrome

3) Por falar em gravação, não poderia ser mais fácil gravar o firmware na flash. Quando você liga o kit na USB do seu PC, ele irá criar automaticamente o drive “MBED”, como se fosse um pendrive. Para gravar o firmware, basta copiar o arquivo binário gerado para este diretório. Muito fácil.

4) E por último, o desenvolvimento é todo baseado em bibliotecas disponibilizadas pelo projeto. Tem biblioteca para todas as interfaces do microcontrolador. Como vocês verão a seguir, fica muito fácil escrever algo para usar a porta serial ou a interface CAN, por exemplo.

CARREGANDO O PRIMEIRO PROGRAMA

Carregar o primeiro “Hello World” foi questão de segundos, sem brincadeira! Conectei o kit na USB e apareceu o drive “MBED”. Dentro dele cliquei no arquivo “MBED.HTM”, que abriu o navegador e pediu para fazer um cadastro rápido. Após o cadastro, apareceu a página inicial do projeto com um link para baixar a aplicação “HelloWorld.bin”. Cliquei no link, baixei a aplicação para o drive “MBED” e reiniciei o kit. Pronto! A aplicação “Hello World” já estava rodando (um led piscando).

Tela inicial do ambiente de desenvolvimento mbed

Esta tela inicial possui os seguintes menus:

• Blog: acesso ao blog do projeto mbed.

• Forum: onde você pode tirar suas dúvidas e resolver problemas.
• Handbook: Muita documentação sobre o projeto: hardware, ambiente de programação, compilador, bibliotecas, etc.
• Cookbook: Wiki que pode ser acessada e editada por qualquer usuário para documentar bibliotecas e escrever tutoriais, por exemplo.
• My home: Seu perfil, log de atividades, seus programas e bibliotecas.
• My notebook: Suas anotações.
• Compiler: O compilador na nuvem. É aqui que a diversão começa!

PROGRAMANDO

O menu “Compiler” dá acesso ao ambiente de desenvolvimento do kit. Ao criar o primeiro projeto, o ambiente gera automaticamente o arquivo main.cpp com o código abaixo:

1
2
3
4
5
6
7
8
9
10
11
12

#include "mbed.h"
 
DigitalOut myled(LED1);
 
int main() {
    while(1) {
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

É o código do “Hello World” que carregamos anteriormente. Veja que as bibliotecas estão implementadas em C++.

Clicando em “Compile”, o processo de compilação é quase que instantâneo, abrindo uma janela para salvar o arquivo .bin gerado. Basta salvar no drive “MBED” e reiniciar o kit para a primeira aplicação estar funcionando.

Obs: Não esqueça de remover qualquer arquivo .bin antes de copiar para o drive “MBED”, já que com dois arquivos .bin lá dentro, o kit mbed pode não saber qual aplicação usar.

Ao ler o código, e sem consultar biblioteca nenhuma, tentei intuitivamente fazer os quatro leds piscarem, com o código abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include "mbed.h"
 
DigitalOut myled1(LED1);
DigitalOut myled2(LED2);
DigitalOut myled3(LED3);
DigitalOut myled4(LED4);
 
int main() {
    while(1) {
        myled1 = !myled1;
        myled2 = !myled2;
        myled3 = !myled3;
        myled4 = !myled4;
        wait(0.5);
    }
}

E não é que funcionou de primeira! O uso dos bibliotecas é bem intuitivo.

Consultei rapidamente a documentação da biblioteca da porta serial, e com duas linhas adicionais no código já estava enviando dados pela serial.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include "mbed.h"
 
DigitalOut myled1(LED1);
DigitalOut myled2(LED2);
DigitalOut myled3(LED3);
DigitalOut myled4(LED4);
 
// default 9600 N81
Serial pc(USBTX, USBRX);
 
int main() {
    while(1) {
 
        myled1 = !myled1;
        myled2 = !myled2;
        myled3 = !myled3;
        myled4 = !myled4;
 
        pc.printf("Hello Embedded World!\n");
 
        wait(0.5);
    }
}

Com mesma interface USB o kit mbed emula um porta serial (no Linux, cria um device em /dev/ttyACM0). Basta usar qualquer aplicação de terminal serial apontando /dev/ttyACM0 e configurado com 9600 8N1 para receber a mensagem.

É realmente muito divertido programar com este kit. E existe uma espécie de rede social dentro do ambiente de desenvolvimento. Você pode por exemplo publicar e compartilhar seus projetos direto do compilador, de forma que outras pessoas possam reusar e melhorar seu código.

É claro que nem tudo são flores, e a plataforma mbed tem algumas deficiências. E se você estiver desenvolvendo seu projeto e o link de internet cair? Vai namorar, jogar videogame ou brincar com seu cachorro, porque sem internet você perde acesso ao ambiente de desenvolvimento. Debbuging no kit é outro problema. Como ele não tem uma interface JTAG, você precisará aplicar técnicas “old school” usando os leds ou enviando prints na porta serial para debugar sua aplicação. O compilador online também é carente de algumas funcionalidades como auto-complete de código e buscas avançadas. 

Mas o projeto chama a atenção por quebrar alguns paradigmas e ser bastante inovador.

ONDE COMPRAR

Para quem estiver interessado, o kit mbed pode ser adquirido lá fora através da Embedded Artists, Digikey ou LPC Tools. Aqui no Brasil, o kit pode ser adquirido na Anacom, Arrow, Avnet ou Karimex. O valor FOB médio de todos eles é USD 59,00.

No próximo artigo, para explorar melhor todas as possibilidades e interfaces do kit mbed, iremos usá-lo junto com a LPCXpresso Base Board, que tem diversas interfaces de I/O disponíveis, e quem sabe colocar o FreeRTOS para rodar nele.

Um abraço,

Sergio Prado

Posts relacionados:

1. Novos brinquedos no pedaço: mbed e LPCXpresso

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Projetando na nuvem com o kit mbed.

Finalmente tenho em mãos um ARM Cortex-M. Na verdade, agora tenho dois! :)

A NXP gentilmente me forneceu dois kits de desenvolvimento para que eu pudesse avaliar a plataforma ARM Cortex-M. E são duas plataformas badaladas: o kit de desenvolvimento mbed e o kit LPCXpresso.

O mbed é mais do que um kit de desenvolvimento. É uma plataforma de prototipagem na nuvem! Nossa Sergio, o que é isso? Alguma espécie de ferramenta de desenvolvimento pós-morte? Claro que não! :)

Kit mbed — Fonte mbed.org

O mbed é uma plataforma criada pelos engenheiros da própria ARM para diminuir a curva de aprendizagem em projetos com ARM, onde todo o ambiente de desenvolvimento (editor de código, compilador, etc) esta na internet. Então tudo o que você precisa para desenvolver é o próprio kit de desenvolvimento e um navegador web. Realmente, é uma idéia muito interessante e que me agrada bastante.

O kit é baseado no NXP LPC1768, um ARM Cortex-M3 com 512K de memória Flash, 32K de RAM e diversas interfaces como CAN, SPI, I2C e Ethernet. No site do projeto tem bastante documentação, vídeos, código-fonte, etc; e tem também um artigo bem legal sobre o mbed no Blog do Je.

Diagrama do kit mbed — Fonte mbed.org

Já o kit LPCXpresso é uma plataforma de baixo custo para microcontroladores ARM da NXP. O kit é composto por uma placa base da Embedded Artists e uma placa LPCXpresso, possibilitando o uso de diferentes modelos de microcontroladores.

LPCXpresso: placa base e LPC1114 — Fonte: embeddedartists.com e nxp.com

O kit que recebi é o LPCXpresso LPC1114, o primeiro ARM Cortex-M0 lançado no mercado, rodando a 50MHz, com 32K de flash, 8K de RAM e diversas interfaces para você “pintar e bordar” como USB, SPI, I2C, CAN, conversores A/D, e muitos, mas muitos outros I/Os! A plataforma de desenvolvimento é baseada no Eclipse, com debugger JTAG integrado e … suporte a Linux! Isso mesmo, eles não esqueceram do pinguim mais amado deste planeta…:)

Estou ansioso para começar a desenvolver alguns projetos nestes kits, e vocês podem esperar vários artigos baseados nestas arquiteturas nas próximas semanas!

Um abraço,

Sergio Prado

Sem posts relacionados.

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Novos brinquedos no pedaço: mbed e LPCXpresso.

A Texas Instruments possui um portfolio grande de processadores para soluções embarcadas como o microcontrolador de 16 bits MSP430, a plataforma C2000 para aplicações de tempo real, a linha ARM com as séries Sitara e Stellaris, seus famosos DSPs Integra e DaVinci para aplicações multimídia, e a família OMAP para aplicações mobile (arquitetura usada na Beagleboard).

Recebi recentemente o kit Piccolo controlSTICK USB para avaliação do novo microcontrolador Piccolo da TI. O kit é realmente pequeno, quase do tamanho de um pendrive.

Ele é baseado na arquitetura C2000, voltado para aplicações real-time e com o core da CPU otimizado para operações aritméticas. Esta CPU busca um meio termo entre a capacidade de processamento de um DSP e a facilidade de uso de um microcontrolador. Pode ser usado em diversos tipos de aplicações como smart grids para controle de energia, comunicação pela rede elétrica (PLC) e soluções automotivas.

O kit controlSTICK usa a CPU TMS320F2806x, com clock de 80MHz e capacidade de trabalhar com ponto flutuante, 128K de memória flash e 100K de RAM, 12 canais A/D, I2C, SPI, CAN e 54 pinos de I/O. De acordo com as especificações, o PWM pode trabalhar com a impressionante resolução de 65ps e os canais ADC com uma taxa de amostragem de 12.5 MSPS.

Um CD de instalação acompanha o kit, com os drivers para Windows, ferramentas e aplicações. Para usar o kit, basta conectá-lo em uma porta USB e instalar os drivers. A ferramenta controlSUITE disponibiliza todo um ambiente para facilitar a codificação das aplicações, com drivers, bibliotecas, exemplos e ferramentas de desenvolvimento.

Também disponível no CD de instalação encontra-se uma aplicação com um exemplo bem interessante de Transformada de Fourier (F28069_controlSTICK.exe), que me fez lembrar das aulas de telecomunicações no colégio técnico…:)

Esta aplicação se comunica com a CPU através de uma conexão JTAG pela porta USB do PC. O primeiro gráfico é uma combinação de três ondas senoidais cujas frequências são configuradas no campo “Input Frequencies”. O segundo gráfico elimina todas as frequências abaixo da frequência configurada em “Frequency cutoff”. O terceiro gráfico é o espectro de frequências do sinal. Todos estes cálculos foram realizados pela unidade de ponto flutuante (FPU) do microcontrolador.

Se você precisa de uma arquitetura de CPU com características de real-time, uso de canais ADC e operações de ponto flutuante, a arquitetura C2000 pode ser uma boa solução.

Eu ainda pretendo usar este kit para testar uma aplicação com comunicação pela energia elétrica. Continuem acompanhando!

Um abraço,

Sergio Prado

Sem posts relacionados.

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Kit Piccolo controlSTICK da Texas Instruments.

Recentemente comprei o kit FriendlyARM Mini2440, e escrevi um post introdutório sobre ele aqui.

Minhas impressões iniciais são muito boas. Ele é possivelmente um dos melhores kits existentes (que conheço) para se aprender sobre Linux embarcado, por ser um hardware robusto, pelas ferramentas existentes e pela relação custo/benefício.

Vamos ver então com um pouco mais de detalhes a arquitetura da CPU, o layout de memória e o bootloader que vem instalado de fábrica.

CPU E O LAYOUT DE MEMÓRIA

O kit, com todas as suas interfaces de I/O e memória, pode ser visto na figura abaixo:

A CPU é um Samsung S3C2440 baseado no core ARM920T, RISC, arquitetura Harvard e voltado para aplicações de baixo consumo. O datasheet pode ser baixado aqui.

Tem capacidade de endereçamento de até 1GB, sendo 8 bancos de memória de 128M selecionáveis através de 8 chip select’s (nGCS0…nGCS7).

A memória RAM de 64MB (2 x 32MB) está mapeada para o endereço físico 0x30000000 através do nGCS6.

Existem duas memórias de programa neste kit, o que acaba sendo um diferencial perante outros kits ARM voltados para aprendizado. O kit possui 2MB de memória flash do tipo NOR e 64MB de memória flash do tipo NAND.

Para quem não conhece, vale aqui uma explicação sobre as diferenças entre estes dois tipos de memória.

Ambas foram inventadas na década de 80 pela Toshiba. As primeiras memórias NOR foram vendidas pela Intel em 88. Com tempo de resposta para apagar e escrever muito grande, mas com a possibilidade de acesso à leitura em qualquer posição de memória, foi uma aplicação ideal para memórias do tipo ROM, para armazenar programas que dificilmente são alterados, como a BIOS de PCs  e firmware de equipamentos eletrônicos.

Já as memórias do tipo NAND possui um tempo de escrita bem menor, e uma maior densidade, ou seja, mais MB de dados pelo mesmo espaço se comparados com as memórias NOR. Por outro lado, não é possível acesso de leitura à qualquer posição de memória. A leitura e gravação é feita por blocos de memória (4kB por exemplo). Isso dá a ela a aplicação ideal para armazenamento de dados. Quando usada como memória de programa, é necessário ter um bootloader que carrega seu conteúdo em memória RAM para ser executado.

O kit mini2440 consegue fazer o boot pelas duas memórias através de uma chave (NAND <-> NOR) no canto inferior direito da imagem acima.

Ao fazer o boot pela NAND, a CPU possui uma região especial chamada de “Boot internal SRAM”, onde são carregados e executados os primeiros 4KB da NAND. Estes primeiros 4K de programa serão os responsáveis por carregar o resto do programa da NAND para a RAM, e rodar a aplicação a partir de lá.

Ao fazer o boot pela NOR, é carregado o bootloader Supervivi, que vêm instalado de fábrica. Ele é baseado no bootloader open source vivi da Samsung. Vamos dar uma olhada nele com mais detalhes.

BOOTLOADER SUPERVIVI

Para acessar o bootloader ligue os cabos RS232 e USB e deixe a chave de seleção de memória na posição NOR. Você pode usar qualquer aplicação para consoles como o HyperTerminal para Windows ou o minicom para Linux. Este é o menu inicial do bootloader Supervivi:

A opção “q” oferece um shell para o bootloader e as outras opções automatizam determinada tarefa.

Apesar da manipulação do bootloader ser pela console (porta serial), a transferência de arquivos é pela USB. Você vai precisar de uma aplicação adicional para transferir arquivos e imagens: DNW for Windows ou Usb-push for Linux. Nos nossos exemplos usaremos um PC com Linux, mas os procedimentos com Windows são similares, e mais informações podem ser encontradas no manual de usuário do kit aqui.

CARREGANDO UMA APLICAÇÃO STANDALONE

Para carregar uma aplicação standalone na flash NAND, basta usar a opção “a”. Esta aplicação standalone pode ser qualquer binário pronto para execução. Pode ser uma simples aplicação para piscar leds ou uma aplicação mais completa com RTOS. Vamos carregar aqui o binário “myled.bin” na flash, que vem como exemplo junto com o kit:

Primeiro devemos preparar o bootloader para carregar o arquivo com a opção “a”:

[a] Absolute User Application
Enter your selection: a
USB host is connected. Waiting a download.

Depois devemos disparar a transferência com a aplicação usb-push:

$ sudo ./usbpush /media/cdrom0/sample\ code\ without\ OS/myled.bin
csum = 0x83c6
send_file: addr = 0x30000000, len = 0x0000084c

O bootloader vai exibir o status da transferência:

Now, Downloading [ADDRESS:30000000h,TOTAL:2134]
RECEIVED FILE SIZE:    2134 (2KB/S, 1S)
Downloaded file at 0x30000000, size = 2124 bytes
Write to flash ok: skipped size = 0x0, size = 0x84c

Supervivi> part show
Number of partitions: 4
name            :       offset          size            flag
------------------------------------------------------------
vivi            :       0x00000000      0x00040000      0
param           :       0x00040000      0x00020000      0
kernel          :       0x00060000      0x00500000      0
root            :       0x00560000      0x3fa80000      0

Posts relacionados:

1. Kit de desenvolvimento FriendlyARM mini2440
2. Memory leak em linguagem C

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Mini2440 — Memory layout e bootloader.

Por um tempo determinado a Renesas esta oferecendo gratuitamente seu kit de avaliação RX-Stick for RX610. A RX600 é uma série high-end da família RX de processadores, sucessora das famílias H8SX e R32C, arquiteturas de 32 bits da Renesas. Mais informações sobre a série RX600 podem ser lidas aqui.

O kit tem uma CPU de 32bits rodando a 100MHz, 2MB de Flash e 128KB de RAM, gravação e debugging pela USB, matriz de leds, potenciômetro, joystick de quatro direções, etc. A Renesas criou uma página no site de sua comunidade online para este kit com bastante documentação e software de exemplos para a utilização do kit, além de um vídeo demonstrando seu funcionamento:

Se você quiser participar e receber um kit gratuitamente, basta fazer um cadastro no site da Renesas aqui.

Atualização: Infelizmente a Renesas não pode atender toda a demanda, e a promoção está cancelada.

Um abraço,

Sergio Prado

Sem posts relacionados.

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Renesas oferece kit de avaliação gratuitamente.

A pouco menos de 2 meses comprei no site do eBay o kit de desenvolvimento FriendlyARM mini2440. O produto foi importado da China e chegou este fim de semana. Fui ao estabelecimento dos Correios, paguei os impostos devidos e retirei o produto.

No total (valor do kit + frete + impostos) o kit saiu em torno de R$360,00. Valor bem mais barato do que se adquirisse por aqui, ou se comprasse um kit ARM similar.

E realmente este kit tem algumas caracteristicas interessantes. A começar pelo tamanho, de 10cm x 10cm. Veja uma foto com a placa do lado do meu Nokia E71:

Além da placa o kit acompanha um display touch screen de 3,5 polegadas e alguns cabos (serial, JTAG, USB, Ethernet), e vem pre-carregado com uma imagem rodando Linux e Qtopia. Veja abaixo o kit montado e rodando:

Suas configurações são impressionantes: CPU ARM9 da Samsung de 400MHz (S3C2440A), 64M de SDRAM, 64M de Nand Flash e 2M de NOR Flash, além de várias interfaces incluindo serial RS232, USB, Ethernet, Cartão SD e JTAG.

Já vem com um bootloader que possibilita carregar a aplicação via USB, e é compatível com os sistemas operacionais Windows CE, GNU/Linux e Android.

Este kit será, durante as próximas semanas, a plataforma que utilizarei para me aprofundar em ARM e linux embarcado, e especialmente no sistema operacional Android do Google.

Alguns posts interessantes sobre este kit estão por vir. Aguardem!

Um abraço,

Sergio Prado

Sem posts relacionados.

Sergio Prado atua com desenvolvimento de software para sistemas embarcados há mais de 15 anos. É sócio-fundador da Embed­ded Lab­works, uma empresa focada em te aju­dar a desen­volver soft­ware de qual­i­dade para sis­temas embar­ca­dos. Se você pre­cisa de ajuda para desen­volver seu pro­duto, ou quer saber mais sobre o que a Embed­ded Lab­works pode fazer por você, acesse http://e-labworks.com/servicos.

Este post foi originalmente publicado em Kit de desenvolvimento FriendlyARM mini2440.