Microcontroladores

Não pretendo fazer uma introdução formal aos microcontroladores, minha experiência com eles é limitada e essencialmente prática. Além disso, textos introdutórios de excelente qualidade sobre o assunto são facilmente encontrados na internet. Aqui serão discutidos alguns tópicos práticos relacionados a características da programação de microcontroladores que talvez os programadores acostumados a programar computadores não estejam habituados. O código usado como exemplo usa a biblioteca do Wixel que contém o CC2511F32 da Texas Instruments. Mas mesmo para quem usar outro microcontrolador, penso que serão de muita ajuda para os iniciantes porque os conceitos são basicamente os mesmo para qualquer microcontrolador.

Antes de tratar sobre a programação é importante conhecer alguns conceitos básicos usados na arquitetura dos microcontroladores então sugiro enfaticamente uma pesquisa introdutória sobre o assunto. Abaixo alguns links:

• Como funcionam os microcontroladores
• Introdução aos Microcontroladores
• Introdução ao Microcontrolador.
• Microcontroladores industriais (apostila)
• Introdução aos Microcontroladores (apostila)

Loop infinito

A primeira coisa a saber sobre programação de microcontroladores é que o programa está sempre rodando dentro de um loop infinito. Quando o microcontrolador é ligado um código de inicialização é executado e em seguida o programa entra em um loop infinito que só termina quando a energia é cortada. Normalmente dentro do loop estão chamadas a funções que monitoram o estado de alguma porta, pino, timer ou qualquer periférico disponível e conforme o caso executam alguma ação ou retornam sem fazer nada,

É preciso lembrar que essas funções serão chamadas uma vez a cada iteração do loop, mas vão (ou deveriam) ocorrer milhares de iterações por segundo. O comportamento esperado é que na grande maioria das chamadas essas funções retornem sem nenhuma ação, então é uma boa estratégia iniciar a função identificando o mais cedo possível essa condição e retornar executando o mínimo de código possível.

Funções não bloqueantes

Quanto mais iterações por segundo o loop principal conseguir fazer, mais precisas serão as medidas feitas nos periféricos e mais imediatas serão as ações de resposta do microcontrolador. Por isso é importante evitar escrever código que mantenha o fluxo de processamento preso em uma instrução ou loop por muito tempo. Por exemplo, instruções que fazem o processamento "esperar" determinada quantidade de tempo ( do tipo delay(tempo) ), devem ser evitadas.

Para entender o problema de usar usar funções bloqueantes, vamos considerar uma aplicação bem simples que envolva alguns pinos. Suponha que o pino P1 deva ser monitorado e que o funcionamento normal do sistema exija este pino em nível alto. Sempre que o pino P1 ficar em nível baixo, um alarme conectado ao pino P2 tem que ser ligado e mantido assim até o pino P1 voltar ao nível alto. O programa para esta especificação poderia ser algo como:

#define mnPin    P1
#define pinAlarm P2
 
void main()
{
    // inicializacão
    setDigitalInput(mnPin, HIGH_IMPEDANCE);
    setDigitalOutput(pinAlarm, LOW);
 
    // loop principal
    while(1)
    {
        // monitoramento
        pinAlarm = !mnPin ;
    }
}
 

Apesar de simples e básico, o código acima é extremamente eficiente e preciso. No instante em que P1 estiver em nível baixo, o pino de alarme é ativado. Isso será verificado milhares de vezes por segundo, então a reação será praticamente imediata.

Entretanto, qualquer microcontrolador atual pode dar conta de muito mais código do que o programa acima, então vamos acrescentar mais uma funcionalidade à aplicação: um led de status. A função desse led é indicar que o microcontrolador está ligado e funcionando, para isso faremos ele piscar em ciclos de 1 segundo, ficando meio segundo apagado e meio segundo aceso. Assumindo que seja usado o pino P3 para ativar o led, poderia ser feita uma implementação como o programa abaixo:

#define mnPin     P1
#define pinAlarm  P2
#define pinStatus P3
 
#define on  1
#define off 0
 
void main()
{
    // inicializacão
    setDigitalInput(mnPin, HIGH_IMPEDANCE);
    setDigitalOutput(pinAlarm, LOW);
    setDigitalOutput(pinStatus, LOW);
 
    // loop principal
    while(1)
    {
        // monitoramento
        pinAlarm = !mnPin;
 
        // led de status
        pinStatus = on;
        delay(500);
        pinStatus = off;
        delay(500);
    }
}
 

A função delay() faz com que o processador espere a quantidade de milissegundos indicada no argumento. A cada iteração do loop principal, o programa agora verifica o pino monitorado, em seguida liga o led de status e espera meio segundo. A seguir o led de status é desligado e novamente há uma espera de meio segundo. Este código faz o que é pedido, mas agora cada iteração demora pelo menos um segundo para ser completada. Isso significa que se o pino P1 for para o nível baixo logo após ele ser verificado, pode demorar até um segundo para que o alarme seja ativado. Essa demora pode ser aceitável em algumas aplicações, mas também pode inviabilizar outras. Suponha que o alarme signifique uma sobrecarga elétrica no sistema e o mesmo sinal que ative o alarme também desligue o dispositivo sobrecarregado. Nesse caso, um segundo é tempo mais que suficiente para torrar o dispositivo que deveria estar sendo protegido.

Mas então como fazer para piscar o led de um modo não-bloqueante? Veja o código abaixo:

#define mnPin     P1
#define pinAlarm  P2
#define pinStatus P3
 
void blinkStatusLed()
{   static uint32 nextToggle = 0;
 
    if(getMs() >= nextToggle)
    {
        pinStatus = !pinStatus;
        nextToggle = getMs()+500;
    }
}
 
void main()
{
    // inicializacão
    setDigitalInput(mnPin, HIGH_IMPEDANCE);
    setDigitalOutput(pinAlarm, LOW);
    setDigitalOutput(pinStatus, LOW);
 
    // loop principal
    while(1)
    {
        // monitoramento
        pinAlarm = !mnPin;
 
        // led de status
        blinkStatusLed();
    }
}
 

A função getMs() faz parte da biblioteca do Wixel e retorna a quantidade de milissegundos decorridos desde que o microcontrolador foi ligado. Uma função com essa funcionalidade existe nas bibliotecas da maioria dos microcontroladores, talvez com outro nome. De qualquer forma, a função permite medir intervalos de tempo em milissegundos.

A nova implementação do programa acrescenta a função blinkStatusLed() que cuida de piscar o led de status. Veja que não há mais chamadas à função delay(). Em vez disso, a variável estática nextToggle armazena quando deverá ser feita a próxima mudança de estado do led somando o valor 500 ao valor retornado por getMs() cada vez que o led muda de estado.

A grande diferença entre esta implementação e a anterior, é que novamente o pino será monitorado milhares de vezes por segundo, já que não existe mais nenhuma espera no processamento. Apesar disso, o led irá piscar em ciclos de 1 segundo, conforme foi especificado.

Led de status piscante

Uma maneira simples de resolver a questão do tópico anterior seria fazer com que o led de status fique sempre aceso em vez de piscar. Isso tornaria o código muito mais simples. Na verdade, o led poderia ser ativado ainda na inicialização e não seria necessário nenhum código dentro do loop principal. Isso simplifica o programa, mas retira uma importante informação de debug. A função do led de status não é só indicar que o microcontrolador está ligado, mas ele também deve informar se a execução está seguindo seu fluxo normal ou se ficou presa em algum loop ou função. Se o led de status está configurado para piscar e em determinado momento ele passa a ficar sempre aceso ou sempre apagado, isso indica que o programa pode ter travado em algum ponto e não está mais seguindo o fluxo normal de processamento. Um led de status que fique sempre aceso não daria essa informação.

Medir tempo com operações bit-a-bit

Como citado, a maioria dos microcontroladores oferece em suas bibliotecas uma função que informa a quantidade de milissegundos decorridos desde a ativação. O valor retornado por essa função é sempre um inteiro positivo. Se analisarmos o comportamento dos bits que compõe esse valor em binário, vamos perceber que cada bit muda de estado em intervalos de tempo bem determinados. Apenas como referência, vamos chamar o bit menos significativo de bit 0, o segundo bit menos significativo de bit 1 e assim por diante.

Se em determinado momento o bit 0 desse valor for 1, no milissegundo seguinte ele será 0 e no próximo milissegundo ele será 1 novamente e assim por diante. Então ele muda de estado a cada milissegundo. Já o bit 1 só vai mudar de estado a cada dois milissegundos, o bit 2 muda de estado a cada 4 milissegundos, o bit 3 muda a cada oito milissegundos e assim por diante dobrando o intervalo a cada incremento de ordem do bit.

Então se precisarmos medir algum intervalo de tempo fixo (por exemplo para a mudança de estado de um led de status) e se esse intervalo for próximo de alguma potência de dois, é muito mais eficiente, rápido e econômico usar os bits do contador de milissegundos do que criar uma variável estática, somar uma valor a ela, comparar o valor da variável com o valor do contador e etc, como foi sugerido acima.

No exemplo anterior foi implementado um código para piscar o led de status a cada meio segundo usando uma variável estática. Meio segundo significa 500 milissegundos e 500 não é uma potência de dois, mas 512 é (2 elevado a 9) e também é um valor próximo o suficiente de 500 para ser aceitável como aproximação nesta aplicação. Veja abaixo uma nova implementação da aplicação do exemplo, agora usando o contador de milissegundos para piscar o led:

#define mnPin     P1
#define pinAlarm  P2
#define pinStatus P3
 
void main()
{
    // inicializacão
    setDigitalInput(mnPin, HIGH_IMPEDANCE);
    setDigitalOutput(pinAlarm, LOW);
    setDigitalOutput(pinStatus, LOW);
 
    // loop principal
    while(1)
    {
        // monitoramento
        pinAlarm = !mnPin;
 
        // led de status
        pinStatus = (getMs() >> 8) & 1;  // intervalos de 512 ms
    }
}
 

Operações bit-a-bit ocupam pouca memória e são extremamente rápidas, então este código é muito mais compacto e eficiente do que a versão anterior que usa a função blinkStatusLed(). Além disso, continua sendo não bloqueante.

Heart beat - Batida de coração

Podemos usar um bit do contador de milissegundos para medir um intervalo de tempo específico, como mostrado no tópico anterior, mas combinando vários bits do contador é possível produzir padrões bem interessantes simulando ritmos, por exemplo como o ritmo das batidas de um coração. O princípio é o mesmo da medição de intervalos, só que agora vamos usar mais de um bit para calcular o estado do led de status. Veja o código abaixo:

uint32 ms;
 
ms = getMs();
pinStatus = (ms >> 8) & (ms >> 6) & 1;

Agora, para que o pino de status fique em nivel alto, é preciso que o bit 9 e o bit 7 do contador estejam ambos com o valor 1. Veja que o bit 9 muda de estado a cada 512 milissegundos, então quando o esse bit estiver zerado o led ficará apagado não importa o estado do bit 7. Já o bit 7 muda de estado a cada 128 milissegundos, então no período em que o bit 9 assume o valor 1 (a cada 512 ms) o bit 7 muda de estado 4 vezes produzindo duas piscadas. Então o led vai dar duas piscadas, ficar meio segundo apagado e depois mais duas piscadas, etc. O efeito lembra bem uma batida de coração. Outros ritmos podem produzidos fazendo combinações diferentes de bits do contador de milissegundos.

Tutorial: Módulo de alimentação com o 7805

Reguladores de tensão são circuitos que na sua versão básica (e perfeitamente suficiente) são extremamente simples de projetar e montar. Existem chips que fazem quase todo o trabalho, só precisando de mais dois ou três componentes adicionais no circuito. Os dois chips mais populares para este serviço são o 7805 e o LM317. Os dois são baratos, fáceis de usar e fornecem corrente suficiente para alimentar todos os circuitos do robô. Se você não tem muita experiência com eletrônica, montar teus próprios reguladores de tensão é um ótimo exercício inicial e vai te dar a experiência necessária para encarar circuitos mais complexos.

Importante: O 7805 pode fornecer até 1A de corrente, o LM317 pode chegar a 1.5A. Isso é suficiente para alimentar todos os circuitos do robô, mas não é suficiente para alimentar os motores. Existem chips capazes de fornecer mais corrente, mas com um projeto adequado, os motores podem ser alimentados diretamente pelas baterias, sem necessidade de reguladores. Os reguladores citados acima são apenas para alimentar os circuitos.

O 7805

78xx é uma família de reguladores de voltagem lineares contidos em um circuito integrado. Normalmente é usado em em circuitos que requerem uma fonte regulada de energia que seja fácil de usar e barata. Nos circuitos integrados da família o xx é substituído por dois dígitos que indicam a voltagem de saída do regulador. Então o 7805 tem uma saída de 5 volts, o 7809 de 9 volts, o 7812 de 12 volts e assim por diante. Por ter uma saída fixa, ele não precisa de regulagens externas o que facilita muito seu uso. É um regulador antigo, o que significa que é bem confiável, está no mercado a muito tempo e tem sido amplamente usado em milhões de projetos. Tem todas as proteções internas possíveis, nos fóruns de eletrônica ele é tido como praticamente indestrutível. E é muito barato e fácil de achar. Com certeza esta é uma excelente escolha para o módulo de alimentação de um robô mais simples, especialmente se o aspirante a robot maker por trás do projeto não tiver muita experiência com eletrônica.

A desvantagem é que, pelo menos sua versão mais clássica, o LM7805 sempre foi muito ineficiente ao fazer a conversão da voltagem. Ao reduzir a voltagem, o excesso de energia é convertido em calor. Se o consumo de corrente ultrapassa algo como 500 mAh é necessário usar um dissipador de calor. A eficiência típica do LM7805 fica entre 40% e 50%, o que convenhamos, são valores horríveis. Quer dizer que metade da energia que entra nele é convertida em calor e a outra metade é entregue na saída estabilizada. Em um robô que usa bateria, esses valores são inaceitáveis. Ou seriam, se essa energia fosse muito significativa em relação ao consumo total. É preciso lembrar que o regulador de tensão está sendo projetado para alimentar os circuitos e não os motores.

De qualquer forma, 78xx não é apenas uma família de reguladores, agora já se tornou um padrão para reguladores de voltagem. Então é possível encontrar uma infinidade de reguladores "compatíveis" com 78xx. Isso significa que usam a mesma pinagem, apresentam o mesmo resultado, mas podem usar tecnologias completamente diferentes (mais modernas) e apresentar características bem diferentes do clássico LM7805. Por exemplo, o fabricante do QS7805 afirma que seu chip é capaz de converter uma entrada de 6,5v a 24v em uma saída regulada de 5v com uma eficiência que varia de 85% a 94%. Não esquenta ou esquenta muito pouco dispensando o dissipador de calor. A função, tamanho e espaçamento dos pinos do QS7805 é a mesma do LM7805, então é possível simplesmente retirar um LM7805 da placa e colocar um QS7805 no lugar e imediatamente ter um regulador muito mais eficiente e econômico.


Este chip na sua forma mais comum é encontrado no "package" TO-220, que é a embalagem com 3 pinos mostrada na foto abaixo:

Pinagem do 7805

O pino 1 deve ser conectado ao positivo da fonte de energia (a bateria). O pino central fica ligado ao terra (GND) e a saída com a voltagem regulada (5 volts) é obtida pelo pino 3. Teoricamente, dentro de condições muito ideais, o 7805 poderia até ser usado sozinho, sem nenhum outro componente, conforme mostrado no esquema abaixo. Mas nunca é uma boa ideia contar com condições ideais.

Esquema de ligação do 7805

Capacitores

Capacitores podem ter vários usos na eletrônica, mas neste contexto eles servem como filtros de linha, absorvendo pequenos picos de energia e fornecendo energia quando a voltagem cai ligeiramente.

Quando o circuito é ligado, um capacitor que tenha seus terminais conectados aos polos da fonte de energia, vai absorver energia até ficar carregado com a voltagem fornecida, a partir daí ele não absorve mais, mas fica carregado. Se a voltagem cair ele começa a se descarregar liberando energia para o circuito até que o capacitor e o circuito se equilibrem na mesma voltagem. Um pico de voltagem na fonte de energia vai ser em boa parte absorvido pelo capacitor, porque ele vai tentar se carregar até o nível do pico, absorvendo parte dele. Depois que o pico passa e a voltagem volta ao normal o capacitor começa a liberar a energia absorvida durante o pico gradativamente até se equilibrar com a voltagem do circuito.

Devido a esse comportamento, capacitores costumam ser usados na entrada e na saída de energia para eliminar ou pelo menos diminuir flutuações de energia.

Existem vários tipos de capacitores. Para esta aplicação é comum o uso de capacitores eletrolíticos. Estes capacitores podem ser encontrados em uma variedade muito grande de valores, desde 1uF até 1MF. Também são baratos e facilmente encontrados em lojas de eletrônica.

Capacitores eletrolíticos.

Há dois valores que são relevantes a respeito de um capacitor: sua capacitância e sua voltagem máxima. A capacitância se refere à quantidade de energia que o capacitor consegue armazenar e é expressa em Farads (F). A voltagem máxima indica com até quantos volts ele pode ser carregado sem que algo de ruim aconteça. É recomendado usar capacitores com uma voltagem máxima que seja pelo menos o dobro da voltagem nominal do circuito para garantir que ele não frite com um pico de energia. Então se o circuito é alimentado por baterias de 12 volts, seria recomendado que os capacitores tenham uma voltagem nominal de pelo menos 24 volts. Não tem nenhum problema usar capacitores com uma voltagem máxima maior. A desvantagem é que eles serão maiores, mais caros e ocuparão mais espaço no circuito.

Voltando ao nosso circuito, acrescentar capacitores na entrada e na saída de energia vai tornar a saída do nosso regulador mais estável e oferecer alguma proteção contra picos de energia. Os valores mais comuns para esta aplicação são de 100uF na entrada e de 10uF na saída. Abaixo o esquema do regulador com os capacitores.

Observações: Capacitores eletrolíticos são polarizados, isso significa que seus terminais precisam ser conectados nos polos certos. Inverter os polos de um capacitor eletrolítico faz com que ele perca o isolamento interno e fique definitivamente danificado. Todos eles tem uma faixa com um sinal de menos. Essa faixa indica o terminal que deve ser ligado ao terra (ou negativo).

Diodos

Diodo é o mais simples tipo de semicondutor. É um componente com dois terminais que tem a interessante característica de só deixar passar corrente em um sentido. Então ele é muito usado para proteger circuitos contra inversão de polaridade. Acrescentar um diodo à entrada de energia do circuito garante que ele só vai ser alimentado com a polaridade certa. Se alguém inverter os polos da bateria, o circuito simplesmente não funciona em vez de torrar os capacitores como poderia acontecer. O 7805 tem proteção interna contra inversão de polaridade, mas os capacitores eletrolíticos não têm e são muito sensíveis à inversão de polos.

Abaixo o esquema já com o diodo de proteção.

Interruptor

Isto é meio que óbvio, mas não pode ser esquecido. É preciso ter uma chave geral que ligue/desligue a alimentação do robô e o melhor local para isso é no circuito de alimentação. Para ser efetivo, o interruptor deve estar conectado à entrada de energia, não faz muita diferença em qual polo. No circuito acima o interruptor pode ser conectado imediatamente antes ou depois do diodo, ou ser instalado no polo negativo da bateria (GND), como no esquema abaixo:

Led de status

Uma indicação visual que mostre se o circuito está ligado ou desligado é extremamente importante e evita problemas futuros. Para esse fim é comum o uso de leds. Tecnicamente, leds são diodos, só deixam passar corrente em um sentido, mas eles têm essa característica de emitir luz quando tem corrente passando por eles. Leds são muito práticos, mas também são bastante sensíveis, existe um limite de corrente que eles podem suportar e que depende do tipo do led. Para este tipo de aplicação, o mais indicado é usar leds comuns de 3mm. Estes leds não consomem muita corrente então não interferem muito no consumo de energia.

exemplo de leds comuns com 5mm (à esquerda) e 3mm (direita). 5

Para limitar a corrente que passa pelo led, é necessário usar um resistor. Resistores são componentes que, como o nome indica, apresentam resistência à passagem de corrente. Então a corrente é obrigada a diminuir sua intensidade sempre que passa por um resistor. Para leds comuns de 3mm alimentados com 5 volts, podem ser usados resistores de 220 a 470 ohms. Quanto maior o valor do resistor, menos corrente irá passar e o led vai acender com menos intensidade. Valores mais baixos fazem o led acender com mais intensidade, mas diminuem a vida útil do led.

O melhor lugar para posicionar o led é próximo à saída do circuito, como mostrado no esquema abaixo:

Alimentação dos motores

Se estivéssemos fazendo apenas um regulador de tensão para 5 volts, já estaria pronto com o esquema acima. Mas o robô precisa de um pouco mais do que um regulador de tensão, ele precisa de um módulo de alimentação. Apesar de os motores não usarem a saída regulada de 5 volts, eles ainda precisam ser alimentados e já que estamos fazendo um circuito de alimentação, não custaria muito e facilitaria bastante se este circuito já tivesse também uma saída própria para os motores.

Se, como sugerido, a bateria fornece uma voltagem adequada para os motores, podemos simplesmente acrescentar um conector conectado ao positivo da bateria e ao terra do circuito. Se a conexão ao positivo for feita depois do diodo D1, então também os motores ficarão protegidos contra inversão de polaridade:

Mas o nosso módulo de alimentação ainda tem um problema. Note que toda a energia consumida pelo robô, incluindo motores e circuitos, passa pelo diodo D1. Os diodos da família 1N400x só suportam no máximo 1 amper. Os circuitos do robô não consomem muita corrente, mas por segurança, vamos considerar que em conjunto consumam 500 mAh. Já os motores vão consumir pelo menos 500 mAh cada um, embora isso dependa muito do motor. Também são comuns motores de passo que consomem 1 amper/h cada.

De qualquer forma, o total de corrente que vai passar pelo diodo é maior que seu limite máximo de 1 amper e portanto ele não vai aguentar. Para esse problema existem 3 soluções:

1. Usar um diodo com mais capacidade de corrente. Esta é a melhor opção. O diodo 1N5408 consegue suportar até 3A. Não é caro, só é mais difícil de achar do que os diodos da família 1N400x. Existem também opções acessíveis que suportam até 6A. Mais do que isso os diodos começam a ficar grandes e caros demais para este projeto.
2. Pegar a saída para os motores antes do diodo D1. Nesse caso apenas a corrente que alimenta os circuitos é que passa pelo diodo, mas não a corrente que alimenta os motores. É uma solução simples, mas a proteção para os motores é perdida.
3. Usar dois (ou três) diodos em paralelo. Ao passar por diodos em paralelo, a corrente se divide por eles. Por exemplo, se o robô está consumindo no total 1600 mAh, então dois diodos em paralelo só terão que suportar 800 mAh cada um, ficando dentro dos limites de operação deles.

Abaixo o esquema do módulo de alimentação usando dois diodos em paralelo. Importante lembrar que dependendo do consumo dos motores usados, dois diodos podem não ser suficientes, nesse caso é necessário acrescentar mais diodos ou usar diodos com maior capacidade de corrente.

Ultracapacitores

No post anterior eu falei sobre baterias e aproveitando o assunto, resolvi falar um pouco desta tecnologia que muito em breve vai fazer parte do nosso dia-a-dia.

Capacitores

Capacitores em geral são formados por duas superfícies condutoras muito próximas, mas separadas por algum material isolante (dielétrico). Quando essas duas superfícies são conectadas aos polos de uma fonte de corrente contínua, elas são carregadas com cargas opostas. Estas cargas estão isoladas pelo dielétrico, mas muito próximas. Próximas o bastante para produzir um campo eletro-magnético com intensidade suficiente para criar uma força de atração entre as cargas dos dois lados. É essa atração entre as cargas opostas que permite que a energia seja mantida no capacitor, mesmo que ele seja retirado do circuito. Então ele realmente é capaz de armazenar energia. 

A ideia de usar capacitores para alimentar dispositivos elétricos não é nova, na verdade é bem antiga, o problema é que a quantidade de energia que um capacitor comum consegue armazenar é ridiculamente baixa, mesmo quando comparado a uma pilha AA comum. Claro que a tecnologia vem evoluindo e hoje temos capacitores mais eficientes e com muito maior capacidade que algumas décadas atrás. 

A capacidade de carga de um capacitor depende de muitos fatores, mas principalmente de duas variáveis: a área superficial das placas condutoras e a distância entre elas. Quanto maior a área da superfície das placas, mais carga é possível armazenar nelas. Quanto mais próximas estiverem as placas, mais intenso será o campo eletro-magnético e maior será a atração entre as cargas dos dois lados.

Uma solução que vem sendo empregada a muito tempo para aumentar a superfície das placas é usar finíssimas folhas de metal condutor enroladas em bobinas com um material dielétrico entre elas, isso permite aumentar bastante a superfície das placas sem aumentar muito o tamanho do capacitor. 

Também no material dielétrico houve muita evolução, sempre buscando materiais que permitam diminuir a distância entre as placas sem perder o isolamento elétrico.

Ultracapacitores

Ou megacapacitores ou supercapacitores, usam uma abordagem um tanto diferente das clássicas placas condutoras. Como citado, a capacidade de armazenamento depende da área da superfície do material condutor e da espessura do dielétrico entre os dois polos. Nos ultracapacitores não há exatamente placas e nem folhas metálicas, o que existe é uma nano-estrutura esponjosa de carbono ativado fazendo o papel de uma das placas (eletrodo). Justamente por ser uma estrutura porosa, a área da superfície resultante é enorme mesmo em uma porção diminuta do material. 

Para o que seria a segunda placa, no ultracapacitor 
é usado um líquido condutor chamado de eletrólito. O que ocorre é que a esponja de carbono é mergulhada no eletrólito que penetra pelos seus poros permeando toda a estrutura. Então toda a superfície da estrutura de carbono entra em contato com o líquido. Esse contato produz uma reação química que cria uma película isolante entre o carbono e o eletrólito, que acaba funcionando como dielétrico. 

Portanto além de o eletrodo ter uma área superficial imensa em relação ao volume que ocupa, a espessura do dielétrico é da ordem de algumas moléculas. O resultado é um capacitor com uma capacidade de carga que pode ser centenas de vezes maior que um capacitor comum do mesmo tamanho.

Ultracapacitores

Estes capacitores ainda são muito caros e mesmo tendo uma capacidade de carga muito maior que capacitores comuns, ainda não conseguem competir com baterias mais tradicionais em quantidade de carga armazenada, então o custo benefício não é tão favorável assim, mas isso está mudando. Conforme estes componentes se popularizarem, a produção tende a ficar mais barata. E quanto à capacidade de carga, eles ainda estão no início de sua evolução, muito pode ser pode ser melhorado em uma tecnologia tão recente.

Carga e descarga

Mas mesmo depois que os ultracapacitores baratearem e evoluírem, ainda assim as baterias químicas vão continuar tendo seu espaço em projetos de eletrônica. As características de carga e descarga são na prática opostas quando comparamos as duas tecnologias. 

Ao contrário das baterias químicas, um ultracapacitor tem uma resistência interna praticamente desprezível, então nada limita a corrente durante a carga e descarga. Isso significa que ele pode ser carregado em segundos, ou talvez em frações de segundo. Também quer dizer que o capacitor é capaz de entregar toda a energia armazenada nele de uma só vez em um pulso super-potente.

Essa característica torna os ultracapacitores apropriados para aplicações onde é necessário usar uma grande quantidade de energia em um intervalo de tempo muito curto. Por exemplo, estes capacitores já estão sendo usados para alimentar motores de partida de caminhões.

Na verdade o problema com os ultracapacitores é justamente conseguir que entreguem lentamente, um pouco por vez, a energia que armazenam como fazem as baterias químicas. Para conseguir isso é necessário acrescentar um circuito limitador de corrente, que como todo circuito, vai consumir alguma energia diminuindo a eficiência do capacitor.

Já as baterias químicas dependem de reações químicas para armazenar e fornecer energia. Então embora possam ter uma capacidade de armazenamento de energia muito grande, não podem ser carregadas rapidamente e nem fornecer energia em grande quantidade, mesmo por um período curto de tempo. Mas são perfeitas para alimentar dispositivos de baixo consumo por longos períodos de tempo.

Sistemas híbridos

Não demorou muito para que surgisse a ideia de combinar os ultracapacitores com baterias químicas para juntar as vantagens das duas tecnologias. Um sistema misto usando baterias e ultracapacitores é capaz de prover um fornecimento constante de baixa corrente por um longo período de tempo e eventualmente, quando for necessário, fornecer por um breve período uma descarga de alta potência. 

Sistemas de som automotivo já usam dispositivos com ultracapacitores para alimentar os subwoofers e evitar danos à bateria do carro. O consumo de energia em sistemas de som de alta potência varia de acordo com a música. Em momentos de uso intensivo dos subwoofers, o consumo pode atingir níveis que a bateria do carro não consegue suprir. Nesses momentos o ultracapacitor entra em cena complementando o suprimento de energia. Circuitos embutidos no dispositivo cuidam da carga e descarga dos capacitores e podem oferecer recursos como auto desligamento, voltímetros, leds de status e outros.

Essas belezinhas são caras, mas sua potência impressiona. Na foto abaixo um ultracapacitor de 50 Farads para sistemas de som automotivos. Se fosse carregado com 16 volts e descarregasse toda a energia armazenada em 1 segundo, a potência liberada seria de 6,4 kW/s. 

Ultracapacitor automotivo de 50 Farads