- O que são fusíveis no AVR - uma explicação detalhada
- Fuse Bits no Arduino
- Componentes necessários para testar fusíveis no AVR
- Esquema para testar os bits do fusível no AVR
- Testando os fusíveis no AVR
Neste tutorial, vamos falar sobre fusíveis. Quando eu estava na faculdade e aprendendo sobre todas as coisas legais da eletrônica, ouvi o termo fusível no AVR pela primeira vez. Meu pensamento inicial sobre o assunto foi, oh! há algo dentro do AVR que explodirá se eu fizer algo errado. Naquela época, não havia muitos recursos disponíveis na Internet para navegar. Pesquisei bastante para descobrir que esses fusíveis se referiam a alguns bits especiais dentro do microcontrolador AVR. Esses bits são como pequenos interruptores dentro do AVR e, ao ligá-los / desligá-los, podemos ligar / desligar alguns recursos especiais do AVR. Ligar e desligar significa configurar e redefinir.
Vamos aproveitar esta oportunidade para discutir tudo o que há sobre os bits Fuse no AVR. Para simplificar, tomaremos o exemplo de uma placa Arduino que hospeda o popular microcontrolador ATmega328P. Aqui, você aprenderá como configurar esses fusíveis para ativar e desativar alguns desses recursos, o que é muito útil em aplicações da vida real. Então, vamos direto ao assunto.
Em nossas postagens anteriores, construímos muitos projetos de microcontroladores AVR, como o módulo GSM de interface com microcontrolador AVR e a interface HC-05 com microcontrolador AVR. Você pode verificá-los se quiser saber mais sobre esses projetos.
O que são fusíveis no AVR - uma explicação detalhada
Conforme discutimos anteriormente, os fusíveis no microcontrolador são como pequenos interruptores que podem ser ligados e desligados para ativar e desativar vários recursos do microcontrolador AVR. Esta é a parte em que surge nossa próxima pergunta, então como configuramos ou reinicializamos esses fusíveis? A resposta a esta pergunta é simples: Fazemos isso com a ajuda de registradores de fusíveis.
No ATmega328P IC, há um total de 19 bits de fusível e eles são divididos em três bytes de fusível. Esses são definidos como “Bytes de fusível estendidos”, “Byte de fusível alto” e “Byte de fusível baixo”.
Se você olhar a Tabela 27 da folha de dados do ATmega328 / P Rev: 7810D – AVR – 01/15, poderá descobrir todos os pequenos detalhes sobre os bits de fusível. Mas a imagem abaixo lhe dará uma idéia melhor sobre a seção de bits de fusível da folha de dados.
Agora que você aprendeu um pouco sobre os bits de fusível, vamos dar uma olhada na folha de dados e descobrir todos os detalhes necessários sobre este IC.
Os bits de fusível estendidos:
Depois de clicar na guia Fuse Bits e rolar um pouco para baixo, você encontrará a Tabela 27-5: que mostra a tabela para o “Byte de fusível estendido” comumente conhecido como “ EFUSE”. A imagem abaixo mostra exatamente isso.
Nesta tabela, existem apenas três bits utilizáveis e os outros três são reservados. Esses três bits lidam com o nível de detecção de brownout. Como você pode ver na Nota, se olharmos a Tabela 28-5, podemos encontrar mais detalhes sobre ela.
Como você pode ver na tabela acima, temos a tabela de Detecção de Brownout. A detecção de brownout é um recurso que redefine o microcontrolador quando a tensão de alimentação cai abaixo de um determinado nível de tensão. No ATmega328P IC, podemos desabilitar completamente a detecção de brownout ou podemos configurá-la para os níveis que são mostrados na tabela acima.
Os bytes do fusível alto:
Como você pode ver na imagem abaixo, a tabela 27-6: da folha de dados mostra os bits de fusível superiores do CI ATmega328P.
O fusível alto lida com várias tarefas dentro do microcontrolador ATmega328. Nesta seção, falaremos sobre os bits de fusível superiores e seu funcionamento. Vamos começar com os bits BOOTRST, BOOTSZ0 e BOOTSZ1. Esses três bits são responsáveis por definir o tamanho da inicialização; tamanho de inicialização refere-se à quantidade de memória reservada para instalar o carregador de inicialização.
Um bootloader é um software especial executado em cima do microcontrolador e gerencia diferentes tarefas. Mas, no caso do Arduino, o bootloader é usado para fazer o upload do esboço do Arduino dentro do microcontrolador. Em um de nossos artigos anteriores, mostramos como gravar o bootloader no ATmega328P usando o Arduino. Você pode conferir se estiver interessado no assunto. Voltando ao nosso tópico, os objetivos de outros bits no byte alto são razoavelmente claros, o bit EESAVE é preservar a memória EEPROM enquanto um ciclo de apagamento de chip é executado. O bit WDTON serve para habilitar ou desabilitar o Watchdog Timer.
O cronômetro de watchdog é um cronômetro especial no ATmega328P IC que tem seu relógio separado e funciona de forma independente. Se o cronômetro de watchdog estiver habilitado, você precisará zerá-lo com um determinado período, caso contrário, o cronômetro de watchdog irá zerar o microcontrolador. Este é um recurso útil que vem em muitos microcontroladores se o processador travar; o watchdog o redefinirá para evitar qualquer dano ao aplicativo final.
O bit DWEN existe para habilitar o fio de depuração; este é um protocolo preparatório embutido internamente em seu hardware, que é usado para programar e depurar os processadores. Com esse recurso habilitado, você pode atualizar e depurar o processador com um único fio conectado. Mas, para usá-lo, você precisará de um hardware especial que seja preparatório para a Atmel.
Os dois bits restantes são aqueles que você precisa evitar, a menos que saiba exatamente o que está fazendo. Esses são o RSTDISBL bit-7 e o SPIEN bit-5. O RSTDISBL (External Reset Disable), como o nome indica, desativa o pino de reinicialização do hardware externo, e o bit SPIEN é usado para desabilitar a interface de programação SPI. Desativar qualquer um desses dois bits pode bloquear completamente o seu AVR; portanto, deixá-los sozinhos é uma boa ideia.
The Low Fuse Bytes:
Como você pode ver na imagem abaixo, a tabela 27-7: da folha de dados mostra os bits do fusível inferior do CI ATmega328P.
Este byte fusível é responsável por configurar a fonte do relógio e alguns outros parâmetros do relógio dentro do AVR. Nesta seção, aprenderemos sobre tudo isso.
O 7º bit ou o sinalizador CKDIV8 podem ser configurados para dividir a fonte do relógio por 8, isso é muito útil, pois você já deve saber se já tentou programar o AVR. O próximo bit é o bit CKOUT e é o 6º bit no Low Fuse Byte. Sua programação geraria o sinal de clock interno na PORTB0 do microcontrolador.
Os bits 5 e 4 SUT1 e SUT0 controlam o tempo de inicialização do microcontrolador. Isso evita quaisquer ações de inicialização que podem ou não ocorrer antes que a tensão de alimentação possa atingir um nível de tensão limite mínimo aceitável. E os quatro bits CKSEL0-4 finais são usados para selecionar a fonte do relógio do microcontrolador. A tabela abaixo fornece uma melhor compreensão desses quatro bits que são responsáveis por configurar a fonte do relógio. Você pode encontrar esta tabela na seção Fonte do relógio da ficha técnica.
Agora, antes de prosseguirmos, há mais uma coisa que devo examinar é a tabela de atraso de inicialização do oscilador. Por atraso de inicialização, estamos nos referindo aos bits 4 e 5 do byte inferior do fusível. Os atrasos precisam ser ajustados dependendo da condição em que o circuito irá operar e do tipo de oscilador que você está usando. Os valores padrão são definidos para aumentar a potência lentamente com 6 ciclos de clock quando uma seqüência de inicialização ou desligamento é executada. Em seguida, há outro atraso de 14 ciclos de clock com 65 Ms de atraso após a inicialização.
Ufa! Foi muita informação para digerir. Mas antes de prosseguir, vamos encerrar esta seção com uma nota rápida.
Nota:
Se você olhou atentamente a folha de dados, deve ter notado que programar um bit de fusível significa defini-lo baixo, ou seja, 0 (zero), que é o oposto do que geralmente fazemos para tornar uma porta alta ou baixa. Você deve manter isso em mente ao configurar seus fusíveis.
Fuse Bits no Arduino
Falamos muito sobre fusíveis na seção acima, mas nesta seção, vamos falar sobre como configurá-los e como gravá-los em um microcontrolador. Para isso, precisaremos de uma ferramenta chamada Avrdude. É uma ferramenta que pode ser usada para ler, escrever e modificar a memória em microcontroladores AVR. Funciona com SPI e possui uma longa lista de suporte para diferentes tipos de programadores. você pode baixar a ferramenta no link fornecido abaixo. Além disso, usaremos nosso microcontrolador favorito Arduino.
- Baixe o Avrdude versão 6.3 Windows-ming32
Agora que você tem o Avrdude, você precisa extraí-lo e abrir uma janela de comando nessa pasta. Além disso, se você planeja usá-lo mais tarde, pode adicionar o caminho da pasta à seção de variáveis de ambiente do Windows. Mas vou colocá-lo na minha área de trabalho e abrir uma janela de comando lá. Depois de fazer isso, conectaremos o programador USBasp ao nosso PC e nos certificaremos de que temos o driver adequado para o nosso programador USBasp. Assim que fizermos isso, estaremos prontos e leremos primeiro o valor do fusível padrão. Para fazer isso, você precisa executar o seguinte comando.
avrdude.exe -c usbasp -p m328p -U lfuse: r: low_fuse_val.txt: h -U hfuse: r: high_fuse_val.txt: h -U efuse: r: ext_fuse_val.txt: h
Se tudo estiver certo, este comando lerá os bytes do fusível e os colocará em três arquivos de texto separados. A imagem abaixo dará uma ideia melhor do processo.
Como você pode ver, o Avrdude leu os bits de fusível no Arduino nano e os salvou em três arquivos de texto separados. Agora, nós os abrimos e obtivemos três valores; para EFUSE: 0xFD, para HFUSE: 0XDA, para LFUSE: 0xFF. Este foi o valor de fusível padrão que obtivemos para um Arduino nano. Agora, vamos converter esses bits em binários e compará-los com seus valores padrão da folha de dados. A tabela abaixo mostra exatamente isso.
Por conveniência, os bits do fusível são escritos em valores hexadecimais, mas se os convertermos em valores binários e os compararmos com a folha de dados, saberemos o que está acontecendo. Vamos começar com o Byte de fusível inferior. Como você pode ver na string acima, ele está definido como 0XFF e o valor binário seria 0B11111111.
Comparando Bytes de fusível inferior com Arduino:
|
Byte de fusível baixo |
Bit No. |
Valor padrão em AVR |
Valor padrão do Arduino |
|
CKDIV8 |
7 |
0 (programado) |
1 (não programado) |
|
CKOUT |
6 |
1 (não programado) |
1 (não programado) |
|
SUT1 |
5 |
1 (não programado) |
1 (não programado) |
|
SUT0 |
4 |
0 (programado) |
1 (não programado) |
|
CKSEL3 |
3 |
0 (programado) |
1 (não programado) |
|
CKSEL2 |
2 |
0 (programado) |
1 (não programado) |
|
CKSEL1 |
1 |
1 (não programado) |
1 (não programado) |
|
CKSEL0 |
0 |
0 (programado) |
1 (não programado) |
O Byte de fusível superior é definido como 0XDA no binário que é 0B11011010.
Byte de fusível superior no binário:
|
Byte de fusível alto |
Bit No. |
Valor padrão em AVR |
Valor padrão do Arduino |
|
RSTDISBL |
7 |
1 (não programado) |
1 (não programado) |
|
DWEN |
6 |
1 (não programado) |
1 (não programado) |
|
SPIEN |
5 |
0 (programado) |
0 (programado) |
|
WDTON |
4 |
1 (não programado) |
1 (não programado) |
|
EESAVE |
3 |
1 (não programado) |
1 (não programado) |
|
BOOTSZ1 |
2 |
0 (programado) |
0 (programado) |
|
BOOTSZ0 |
1 |
0 (programado) |
1 (não programado) |
|
BOOTRST |
0 |
1 (não programado) |
0 (programado)) |
A configuração do byte de fusível estendido é definida como 0XFD, em binário é 0B11111101.
Byte de fusível estendido em binário:
|
Byte de fusível estendido |
Bit No. |
Valor padrão em AVR |
Valor padrão do Arduino |
|
- |
7 |
1 |
1 |
|
- |
6 |
1 |
1 |
|
- |
5 |
1 |
1 |
|
- |
4 |
1 |
1 |
|
- |
3 |
1 |
1 |
|
BODLEVEL2 |
2 |
1 (não programado) |
1 (não programado) |
|
BODLEVEL1 |
1 |
1 (não programado) |
0 (programado) |
|
BODLEVEL0 |
0 |
1 (não programado) |
1 (não programado) |
Agora, isso marca o fim desta seção. Até agora, aprendemos muito sobre o microcontrolador AVR e seus fusíveis. Portanto, vamos encerrar este artigo colocando nossa teoria à prova, alterando e experimentando alguns dos fusíveis do Arduino Nano.
Componentes necessários para testar fusíveis no AVR
Falamos muito sobre os fusíveis na parte acima. Mas para prosseguir no artigo, precisamos de alguns componentes de hardware e algumas ferramentas de software. Nesta seção, falaremos sobre eles. Uma lista de componentes necessários com imagens é mostrada abaixo.
- Placa de ensaio - 1
- Arduino Nano - 1
- Programador USBasp AVR - 1
- Cabo USB - 1
- Conversor AVR de 10 pinos para 6 pinos - 1
- Avrdude (ferramenta de software para programação AVR)
- LED - 1
- Resistor 330R - 1
- Cabos Jumper
Esquema para testar os bits do fusível no AVR
A configuração de teste de hardware é mostrada abaixo nesta configuração. Conectamos o Arduino Nano ao PC com um cabo USB e também conectamos o programador USBasp ao PC. O objetivo deste artigo é programar os bits de fusível no AVR. Por esse motivo, conectamos o programador USBasp ao Arduino. A imagem abaixo lhe dará uma idéia melhor da configuração.
Testando os fusíveis no AVR
A configuração de teste é mostrada abaixo. Como você pode ver, conectamos o Arduino e o programador USBasp ao USB do meu laptop.
Agora vamos abrir o IDE do Arduino e fazer o upload de um esboço básico em piscar. O conteúdo do esboço básico do blink é autoexplicativo, então não coloquei nenhum detalhe sobre ele.
Você verá no vídeo que o led no pino nº 13 está piscando como deveria. Agora vamos ajustar as configurações do fusível e definir seus valores padrão. E como vimos anteriormente na folha de dados; o EFUSE é 0XFF; o HFUSE é D9; O LFUSE é: 62. Agora vamos configurá-lo com o Avrdude, fazer um flash e ver o que acontece. O código que usaremos é-
avrdude -c usbasp -p m328P -U lfuse: w: 0x62: m -U hfuse: w: 0xd9: m -U efuse: w: 0xff: m
Depois de fazer isso, você verá que o LED piscará extremamente devagar porque calculamos e programamos o valor para um relógio de 16Mhz e agora, após queimar os fusíveis, é apenas um oscilador RC interno de 1Mhz. É por isso que o LED está piscando tão lentamente. Agora vamos tentar fazer o upload de um esboço novamente. Veremos que o Arduino dá um erro e o código não é carregado. Porque ao alterar os fusíveis, também bagunçamos as configurações do bootloader. Você pode ver isso na imagem abaixo.
Para corrigir isso e colocar o Arduino de volta como era antes, precisamos apenas gravar o bootloader novamente para o Arduino. Para fazer isso, vá para Ferramentas -> Programador- USBasp , e assim que fizermos isso, podemos ir novamente para ferramentas e podemos clicar na opção gravar bootloader. Isso irá queimar novamente o bootloader padrão em seu Arduino e tudo voltará a ser como era antes.
Depois que o bootloader foi atualizado de volta para o Arduino, ele voltou ao seu estado original e a última imagem mostra um LED piscando depois que o bootloader foi queimado novamente.
E isso marca o fim deste artigo. Espero que tenha gostado do artigo e aprendido algo novo. Se você tiver alguma dúvida sobre o artigo, não hesite em colocar um comentário abaixo.