Tackle Computationally Intensive Projects with the ShieldBuddy

Muitos hobbistas, fabricantes e bricolageiros usam placas de desenvolvimento de microcomputadores Arduino para monitorar e controlar seus projetos. Assim, também, faça um número crescente de engenheiros profissionais que podem usar essas placas como plataformas de avaliação e prototipagem para acelerar o desenvolvimento e reduzir os custos associados à avaliação de circuitos integrados (ICs), sensores e periféricos. Como foi discutido em Use Arduino BOBs para Avaliar Rapidamente Sensores e Periféricos, estes engenheiros podem estar trabalhando em equipes menores com restrições de tempo de colocação no mercado (TTM). Como tal, eles tiveram que abraçar múltiplos domínios e tarefas de engenharia, ao mesmo tempo em que encontraram maneiras de acelerar e baixar o custo da avaliação de componentes.

Uma solução é usar o Arduinos juntamente com hardware de código aberto na forma de placas de quebra de sensores e periféricos (BOBs) em conjunto com software de código aberto com bibliotecas associadas e programas de exemplo. Embora exista uma grande variedade de placas Arduino para atender uma série de requisitos de processamento e memória, alguns cálculos são, no entanto, melhor feitos usando uma unidade de ponto flutuante (FPU) para evitar a desaceleração do processador principal. Este problema foi tratado dentro do ecossistema Arduino pelo ShieldBuddy.

Este artigo descreverá várias opções de plataforma de processamento Arduino e por que a capacidade da FPU é tão importante para muitas aplicações. Em seguida, apresentará o ShieldBuddy, uma placa que mantém uma pegada física semelhante às placas Arduino, mas com três núcleos independentes de processamento de 32 bits, cada um funcionando a 200 MHz e cada um com sua própria FPU. O artigo descreverá seu modelo de programação e mostrará como seu ambiente de programação baseado no Eclipse e seu apoio ao ambiente de desenvolvimento integrado (IDE) do Arduino permite que tanto os DIYers quanto os projetistas iniciem rapidamente com ele.

Arduino tanto para recém-chegados como para profissionais

Os recém-chegados ao universo Arduino normalmente começam com o Arduino Uno Rev3 (Figura1), que é baseado no microcontrolador ATmega328P de 8 bits rodando a 16 megahertz (MHz). Esta placa tem apenas 32 kilobytes (Kbytes) de memória flash (programa), 2 Kbytes de SRAM, 14 pinos de entrada/saída digital (E/S), e seis pinos de entrada analógica. Seis dos pinos digitais podem fornecer saídas de modulação de largura de pulso (PWM), e os pinos analógicos também podem ser usados como pinos de E/S digitais, se necessário.

Figura 1: A placa de desenvolvimento Arduino Uno Rev3 é baseada no microcontrolador ATmega328P de 8 bits rodando a 16 MHz. (Fonte da imagem: Arduino.cc)

A pegada dos cabeçalhos do Arduino Uno Rev3, com 14 pinos de E/S digitais, 6 pinos de entrada analógicos e vários pinos de potência, terra e referência, é a base para um enorme ecossistema de placas-filhas chamado de escudos.

Muitos usuários do Uno Rev3 posteriormente avançam para a placa Arduino Mega 2560 Rev3 (Figura 2), que é baseada no microcontrolador ATmega2560 de 8 bits rodando a 16 MHz. Esta placa tem 256 Kbytes de memória flash e 8 Kbytes de SRAM. A pegada de seus cabeçalhos significa que ele pode suportar os mesmos escudos que o Uno, no entanto, cabeçalhos adicionais permitem encaixar 54 pinos de E/S digitais e 16 pinos de entrada analógicos. Neste caso, 15 dos pinos digitais podem fornecer saídas PWM, e - uma vez mais - os pinos analógicos também podem ser usados como pinos de E/S digitais, se necessário.

Figura 2: A placa de desenvolvimento Arduino Mega 2560 Rev3 é baseada no microcontrolador ATmega2560 de 8 bits rodando a 16 MHz. A pegada de seus cabeçalhos significa que pode suportar os mesmos escudos que o Arduino Uno, mas também tem cabeçalhos adicionais, fornecendo um total de 54 pinos de E/S digitais e 16 pinos de entrada analógicos. (Fonte da imagem: Arduino)

Além das limitações impostas por um caminho de dados de 8 bits e um relógio de 16 MHz, nem o Arduino Uno nem os microcontroladores Arduino Mega incluem uma FPU, o que significa que quaisquer cálculos envolvendo valores de ponto flutuante atrasam dramaticamente estes processadores.

Para aqueles usuários que desejam ainda mais poder de processamento, a próxima etapa é o Arduino Due (Figura 3), que tem uma pegada física semelhante ao Arduino Mega, mas que se baseia no processador SAM3X8E Arm® Cortex®-M3 de 32 bits da tecnologia Atmel/Microchip, rodando a 84 MHz. Esta placa tem 512 Kbytes de memória flash, 96 Kbytes de SRAM, 54 pinos de E/S digitais, 12 pinos de entrada analógica, e dois pinos de saída analógica que são acionados por conversores digital-para-analógico (DACs). Neste caso, apenas 12 dos pinos digitais podem fornecer saídas PWM, e - uma vez mais - os pinos analógicos também podem ser usados como pinos de E/S digitais, se necessário. Infelizmente, como o Arduino Uno e o Mega, o processador do Arduino Due não inclui uma FPU.

Figura 3: A placa de desenvolvimento Arduino Due é baseada no processador Atmel SAM3X8E de 32 bits Cortex-M3 de braço rodando a 84 MHz. A pegada de seus cabeçalhos é idêntica à do Arduino Mega. (Fonte da imagem: Arduino.cc)

Muitos usuários - tanto hobbyistas quanto profissionais - desfrutam da alta contagem de pinos das placas de desenvolvimento Arduino Mega e Arduino Due. Mas, mesmo o processador de 32 bits do Arduino Due rodando a 84 MHz pode ser insuficiente para algumas tarefas computacionalmente intensivas. Da mesma forma, os 512 Kbytes de memória flash do Due e 96 Kbytes de SRAM podem ser insuficientes para programas mais substanciais que trabalham com grandes quantidades de dados.

Enquanto os microcontroladores são capazes de lidar com o processamento de quantidades cada vez maiores de dados, alguns cálculos são melhor feitos usando FPUs para maior eficiência e menor latência.

O que são FPUs e por que elas são necessárias?

As razões pelas quais as FPUs são úteis remontam à forma como os computadores lidam com os números. A maneira mais simples de representar números dentro de computadores é usar números inteiros (números inteiros). Além disso, a realização de cálculos usando números inteiros é computacionalmente barata. No entanto, os inteiros são de natureza finita e não podem expressar uma ampla faixa dinâmica.

Isto é problemático para engenheiros e cientistas, pois muitas vezes eles precisam utilizar valores extremamente grandes e pequenos no mesmo cálculo. Por exemplo, os físicos podem ter cálculos que empregam os valores numéricos da velocidade da luz (300.000.000) e a constante gravitacional de Newton (0,00000000006674). Da mesma forma, os engenheiros exigem valores com uma grande faixa dinâmica para tarefas como processamento de sinais digitais (DSP) e para uso em aplicações de inteligência artificial (IA) e aprendizagem de máquinas (ML).

A solução é usar a representação numérica de ponto flutuante, onde o ponto decimal pode "flutuar" em relação aos dígitos individuais do número, permitindo um grau mais fino de "resolução" numérica a ser alcançada. O problema é que, embora um valor de ponto flutuante de 32 bits consuma a mesma quantidade de memória que um inteiro de 32 bits de ponto fixo, realizar cálculos usando valores de ponto flutuante requer muito mais recursos computacionais.

Se o processador for obrigado a realizar cálculos de ponto flutuante usando hardware padrão de ponto fixo, o resultado será um impacto dramático no desempenho desse processador. A solução é equipar o processador com uma FPU especial. Isso permite a execução de uma sofisticada operação de ponto flutuante utilizando muito poucos ciclos de relógio.

É aqui que entra em jogo o ShieldBuddy.

ShieldBuddy traz as FPUs e o alto desempenho ao ecossistema Arduino

Um player relativamente novo no espaço compatível com Arduino, o KITAURIXTC275ARDSBTOBO1 da Infineon Technologies, ou ShieldBuddy (Figura 4), é uma placa de avaliação integrada para o microcontrolador de 32 bits TC275T64F200WDCKXUMA1 TC275 AURIX TC2xx TriCore da Infineon.

Figura 4: O ShieldBuddy TC275 é equipado com o processador Infineon TC275 32-bit multicore em uma placa com a mesma pegada do Arduino Mega e Arduino Due, tornando-o compatível com muitos dos escudos de aplicação que estão disponíveis.(Fonte da imagem: Hitex.com)

Mantendo uma pegada física semelhante ao Arduino Mega e Arduino Due, o ShieldBuddy é compatível com muitos dos escudos de aplicação, mas é distinguível pelo uso do TC275 com seus três núcleos independentes de 32 bits, cada um rodando a 200 MHz e cada um tendo sua própria FPU. Além disso, o ShieldBuddy tem 4 megabytes (Mbytes) de memória flash (8x a do Arduino Due e 16x a do Arduino Mega) e 500 Kbytes de RAM (5x a do Arduino Due e 62x a do Arduino Mega).

Uma maneira de ver isto é que o núcleo do Arduino Mega administra apenas cerca de dezesseis instruções de 8 bits por microssegundo (µs). Em comparação, cada um dos núcleos do TC275 tem um ciclo de 5 nanossegundos (ns), o que significa que cada núcleo pode normalmente executar cerca de 150 a 200 instruções/µs de 32 bits. Como cada um dos núcleos processadores da ShieldBuddy tem sua própria FPU, a placa pode realizar cálculos de ponto flutuante com pouca, ou nenhuma, degradação no desempenho.

Desenvolvendo com o ShieldBuddy

Ao trabalhar com o ShieldBuddy, os desenvolvedores profissionais de software podem desejar usar uma IDE Eclipse, enquanto os amadores e fabricantes podem preferir usar a conhecida IDE Arduino. Ambas as opções são suportadas.

Os usuários do Arduino estarão familiarizados com o fato de que cada esboço (programa) deve ter duas funções padrão: setup(), que é executado uma única vez, e loop(), que é executado uma e outra vez. Os usuários também podem criar suas próprias funções.

Os três núcleos da ShieldBuddy são chamados de Núcleo 0, Núcleo 1, e Núcleo 2. No caso da IDE Arduino, a maioria dos esboços existentes pode ser compilada para uso no ShieldBuddy sem modificações. Por padrão, as funções setup() e loop() - juntamente com quaisquer funções criadas pelo usuário que eles chamam - serão compiladas para serem executadas no Core 0.

Ao criar um novo programa, o usuário pode conseguir o mesmo efeito nomeando estas funções setup0() e loop0(). O usuário também pode criar funções de configuração1() e loop1(), que - juntamente com qualquer função criada pelo usuário que ele chamar - serão automaticamente compiladas para serem executadas no Core 1. Da mesma forma, as funções setup2() e loop2(), juntamente com quaisquer funções que chamem, serão automaticamente compiladas para serem executadas no Core 2.

Por padrão, cada núcleo roda independentemente, o que significa que é possível ter três programas totalmente separados rodando no ShieldBuddy simultaneamente. Dito isto, os núcleos também podem se comunicar entre si usando técnicas como a memória compartilhada. Além disso, cada núcleo pode provocar interrupções suaves nos outros núcleos.

Conclusão

O conceito de código aberto Arduino provou ser tremendamente bem sucedido, e os ecossistemas de hardware e software que se seguiram cresceram para abranger centenas de escudos e milhares de bibliotecas e aplicações.

Embora as primeiras placas de desenvolvimento Arduino, como o Arduino Uno de 8 bits, 16 MHz e o Arduino Mega Arduino fossem um pouco limitadas, implementações mais recentes como o Arduino Due de 32 bits e 84 MHz são significativamente mais poderosas. Mesmo assim, muitos usuários requerem mais espaço de programa (flash), mais espaço de dados (SRAM) e mais poder de processamento do que qualquer Arduino tradicional pode oferecer.

Com 4 Mbytes de memória flash, 500 Kbytes de SRAM e três núcleos de processador 32 bits independentes rodando a 200 MHz, cada um com sua própria FPU, o ShieldBuddy leva o conceito Arduino a um nível totalmente novo, tornando-o de interesse tanto para bricolage extremos quanto para engenheiros profissionais.

Leitura recomendada:

1. Ensinando Eletrônica para Iniciantes Absolutos
2. Aplicação rápida e fácil de FPGAs com o Arduino MKR Vidor 4000
3. Junte-se ao Mundo Produtor com um Kit de Iniciante Arduino fácil de usar