Introdução
Motivação
Em 2005 Máximo Banzi e equipe deram início a revolução da computação física criando o Arduino, um pequeno “computador” capaz de ser programado por não especialistas, algo para gente comum, designers, artistas usarem na composição de suas obras emprestando a elas luz, movimento, ou outros efeitos.
De lá até hoje houve evoluções nos modelos de Arduino e para dar a flexibilidade de ser possível gravar o programa, ou melhor, sketch, a ser executado, há um pequeno programa residente no Arduino que leva a cabo essa funcionalidade e que é executado sempre que ocorre um RESET no microcontrolador dando a chance de se efetuar a carga de uma nova programação.
Esse pequeno programa é o bootloader do Arduino. Todo modelo de Arduino tem um bootloader, escrito e configurado para o seu hardware específico, uma vez que diferem os modelos de microcontroladores para praticamente cada modelo de Arduino.
O bootloader é um programa inicializador cujo objetivo é preparar o hardware para o correto funcionamento das aplicações além de também possibilitar a atualização da tal aplicação. Graças a ele é possível efetuar a carga dos sketchs pela interface serial de comunicação com o computador onde se executa o ambiente de desenvolvimento do Arduino. Sem o bootloader seria necessário recorrer ao uso de gravadores para programar os microcontroladores dos Arduinos.
O bootloader quando ausente pode ser gravado usando um de dois métodos. São eles: High Voltage Parallel Programming; In System Programmer – ISP.
Será abordado aqui o método ISP, que é uma forma de programação em que os dados a gravar são enviados de maneira serializada para o microcontrolador e que pode em geral ser executado com o microcontrolador no próprio circuito de operação, daí a denominação In System, afinal não é necessária a retirada do microcontrolador do circuito. A base do método é a capacidade de comunicação SPI (Serial Peripheral Interface) nativa do microcontrolador. Pode-se ler sobre o SPI neste outro artigo do Blá do Chico intitulado “SPI Serial Peripheral Interface” no URL <https://bladochico.qaplaweb.com.br/2019/07/16/spi-serial-peripheral-interface/>.
Modos de Programação do ATmega328P
Encontra-se aqui um trecho em tradução livre do datasheet do ATmega328P que trata da gravação em memória de programa do tipo FLASH e memória de dados do tipo EEPROM do chip.
Carga Paralela
É descrito aqui como efetuar a programação e verificação paralela da memória Flash de Programa, memória de Dados EEPROM, bits de Bloqueio de Memória, e FUSE bits do ATmega328P.
Denominação dos Sinais
Aqui alguns pinos do ATmega328P são referenciados por nomes de sinais que descrevem sua função durante a programação paralela. Consulte a Figura 1: Programação paralela e a Tabela 1: Mapeamento dos pinos por nomes.
Fonte: Datasheet do ATmega328P
Obs.: (Vcc-0,3V) < AVcc < (Vcc+0,3V), no entanto AVcc deve estar sempre entre 4,5 e 5,5V
| Sinal no Modo Programação | pino | Nome do pino | Pino Arduino | E/S | Função |
| RDY / /BSY | 3 | PD1 | TX | S | 0: Dispositivo ocupado (busy) programando, 1: Dispositivo livre (ready) para novo comando |
| /OE | 4 | PD2 | D2 | E | Saída Habilitada (ativo em baixo) |
| /WR | 5 | PD3 | D3 | E | Pulso de Escrita (ativo em baixo) |
| BS1 | 6 | PD4 | D4 | E | Seletor de byte 1 (0 seleciona byte baixo, 1 seleciona byte alto) |
| XA0 | 11 | PD5 | D5 | E | XTAL Bit 0 de ação |
| XA1 | 12 | PD6 | D6 | E | XTAL Bit 1 de ação |
| PAGEL | 13 | PD7 | D7 | E | Programação de memória e Carga de Página de Dados da EEPROM |
| BS2 | 25 | PC2 | A2 | E | Seletor de byte 2 (0 seleciona byte baixo, 1 seleciona byte alto) |
| Data | 24, 23, 19, 18, 17, 16, 15, 14 | PC[1], PC[0], PB[5], PB[4], PB[3], PB[2], PB[1], PB[0] | A1, A0, D13, D12, D11, D10, D9, D8 | E/S | Barramento de dados bidirecional (Saída quando OE é baixo) |
Fonte: Datasheet do ATmega328P
Para entrar no modo de programação paralela, também chamada de Programação de Alta Tensão, as seguintes operações devem ser empreendidas nesta ordem:
- Colocar os pinos Prog_enable listados na Tabela 2: Valores de pinos usados para entrar no modo Programação a seguir em “0000” lógico, o /RESET e o Vcc em 0V;
- Aplicar de 4,5 a 5,5V entre Vcc e GND. Certificar-se que o Vcc atinge pelo menos 1,8V em no máximo 20μs;
- Aguardar de 20 a 60μs e aplicar de 11,5 a 12,5V no pino /RESET;
- Manter os pinos Prog_enable inalterados por pelo menos 10μs após a aplicação da tensão elevada (12V) para garantir que a assinatura Prog_enable tenha sido travada;
- Esperar por ao menos 300μs antes de emitir qualquer comando da programação paralela;
- Para sair do modo de programação desligar o dispositivo ou colocar o pino /RESET em 0V.
Caso o tempo de subida da tensão de Vcc não cumpra o requisito citado no item 2 acima, pode-se usar o seguinte algoritmo como alternativa:
- Colocar os pinos Prog_enable listados na Tabela 2: Valores de pinos usados para entrar no modo Programação em “0000” lógico, o /RESET e o Vcc em 0V;
- Aplicar de 4,5 a 5,5V entre Vcc e GND;
- Monitorar Vcc, e assim que atingir 0,9 a 1,1V, aplicar de 11,5 a 12,5V no pino /RESET;
- Manter os pinos Prog_enable inalterados por ao menos 10μs após aplicar a tensão de 12V para garantir que a assinatura Prog_enable tenha sido travada;
- Esperar até Vcc realmente alcançar entre 4,5 e 5,5V antes de emitir qualquer comando da programação paralela;
- Para sair do modo de programação desligar o dispositivo ou colocar o pino /RESET em 0V.
| Sinal | # pino do chip | Símbolo | Valor |
| PAGEL | 13 | Prog_enable[3] | 0 |
| XA1 | 12 | Prog_enable[2] | 0 |
| XA0 | 11 | Prog_enable[1] | 0 |
| BS1 | 25 | Prog_enable[0] | 0 |
Fonte: Datasheet do ATmega328P
| XA1 | XA0 | Ação quando XTAL1 é pulsado |
| 0 | 0 | Carga de Endereço de Flash ou EEPROM (Byte de Endereço alto ou baixo determinado por BS1) |
| 0 | 1 | Carga de Dados (byte de dados alto ou baixo para Flash determinado por BS1 |
| 1 | 0 | Carga de Comando |
| 1 | 1 | Sem ação, ocioso |
Fonte: Datasheet do ATmega328P
| Byte de Comando | Comando Executado |
| 1000 0000 | Chip Erase |
| 0100 0000 | Grava bits FUSE |
| 0010 0000 | Grava bits de bloqueio |
| 0001 0000 | Grava na memória Flash |
| 0000 1000 | Lê bytes de Assinatura e Calibração |
| 0000 0100 | Lê bits FUSE e Bloqueio |
| 0000 0010 | Lê a FLASH |
| 0000 0001 | Lê a EEPROM |
Fonte: Datasheet do ATmega328P
Considerações para Gravação Eficiente
O comando e o endereço são retidos no dispositivo durante a gravação. Para gravação eficiente, o seguinte deve ser considerado.
- O comando precisa ser carregado apenas uma vez ao gravar ou ler em múltiplas locações de memória;
- Pular as gravações de 0xFF, que é o conteúdo de toda a EEPROM a menos que o FUSE EESAVE esteja programado e da memória Flash após um “Chip Erase”;
- O byte alto de endereço precisa ser carregado apenas antes de gravar ou ler uma nova janela de 256 palavras na Flash ou 256 bytes da EEPROM. Esta consideração também se aplica à leitura dos bytes de assinatura.
Chip Erase
O Chip Erase apagará as memórias Flash e EEPROM(1), mais os bits de travamento. Os bits de travamento não são resetados até que a memória seja completamente apagada. Os bits FUSE não são alterados. Um Chip Erase deve ser executado antes que a memória Flash ou EEPROM sejam gravadas.
Nota 1: A memória EEPROM é preservada durante o Chip Erase se o FUSE EESAVE estiver programado (nível lógico 0).
Carga do comando Chip Erase.
- Faça XA1 e XA0 valerem “10”. Isto habilita a carga de comandos;
- Coloque BS1 em nível lógico “0”;
- Faça o byte DATA valer “1000 0000”. Isto é o comando Chip Erase;
- De um pulso positivo em XTAL1. Isto carrega o comando;
- Dê um pulso negativo em /WR. Isto inicia o Chip Erase. RDY / /BSY irá a nível lógico “0” (busy) durante a operação de apagamento;
- Espere até que RDY / /BSY vá a nível lógico alto (ready) antes de carregar um novo comando.
Gravando na Memória Flash
A memória Flash é organizada em páginas, veja na Tabela 5. Ao gravar a Memória Flash, os dados de programação são retidos num buffer de página. Isto permite que uma página de dados de programa seja gravada simultaneamente. O seguinte procedimento descreve como gravar toda a memória Flash:
- Carga do comando “Gravar a Flash”
- Ajustar XA1 e XA0 para “10”. Isto habilita a carga de comando;
- Ajustar BS1 para “0”;
- Ajustar os dados para “0001 0000”. Isto é o comando de “Gravar a Flash”;
- Dar um pulso positivo em XTAL1. Isto carrega o comando.
- Carga do byte baixo do endereço
- Ajustar XA1 e XA0 para “00”. Isto habilita a carga do endereço;
- Ajustar BS1 para “0”. Isto seleciona o endereço baixo;
- Ajustar os dados com o byte baixo do endereço (0x00-0xFF);
- Dar um pulso positivo em XTAL1. Isto carrega o byte baixo do endereço.
- Carga do byte baixo de dados
- Ajustar XA1 e XA0 para “01”. Isto habilita a carga de dados;
- Ajustar os dados com o byte baixo de dados (0x00-0xFF);
- Dar um pulso positivo em XTAL1. Isto carrega o byte de dados.
- Carga do byte alto de dados
- Ajustar BS1 para “1”. Isto seleciona o byte alto de dados;
- Ajustar XA1 e XA0 para “01”. Isto habilita a carga de dados;
- Ajustar os dados com o byte alto de dados (0x00-0xFF);
- Dar um pulso positivo em XTAL1. Isto carrega o byte de dados;
- Trava dos dados
- Ajustar BS1 para “1”. Isto seleciona o byte alto de dados;
- Dar um pulso positivo em PAGEL. Isto trava os bytes de dado (Veja a Figura 2 para formas de onda dos sinais).
- Repetir B até E até que todo buffer esteja preenchido ou até que todos os dados da página estejam carregados.
Enquanto os bits baixos do endereço são mapeados para palavras da página, os bits altos endereçam as páginas da FLASH. Isto é ilustrado na Figura 3. Note que se menos de oito bits são requeridos para endereçar palavras na página (tamanho de página < 256), os bits mais significativos no byte baixo de endereço são usados para endereçar a página quando gravando a página.
- Carga do byte alto de endereço
- Ajustar XA1 e XA0 para “00”. Isto habilita a carga de endereço;
- Ajustar BS1 para “1”. Isto seleciona o endereço alto;
- Ajustar os dados com o byte alto do endereço (0x00-0xFF);
- Dar um pulso positivo em XTAL1. Isto carrega o byte alto de endereço.
- Gravar Página
- Dar um pulso negativo em /WR. Isto inicia a gravação de toda a página de dados. RDY / /BSY vai a nível logico baixo (busy) durante a operação;
- Aguardar até RDY / /BSY ir para alto (Ready – Veja a Figura 2 para formas de onda).
- Repetir B até H até que toda a Flash esteja gravada ou até que todos os dados tenham sido gravados.
- Finalizar a Gravação de página
- Ajustar XA1 e XA0 pata “10”. Isto habilita a carga de comandos;
- Ajustar os dados com “0000 0000”. Isto é o comando de “Sem Operação” (NOP);
- Dar um pulso positivo em XTAL1. Isto carrega o comando, e o sinal interno de escrita é resetado.
| Tamanho da Flash | Tamanho da página | PCWORD | Núm. de páginas | PCPAGE | PCMSB |
| 16k words (32k bytes) | 64 words | PC[5:0] | 256 | PC[13:6] | 13 |
Fonte: Datasheet do ATmega328P
Fonte: Datasheet do ATmega328P
Fonte: Datasheet do ATmega328P
Programando a EEPROM
A EEPROM é organizada em páginas, consulte a Tabela 6. Ao gravar a EEPROM, os dados são retidos em um buffer de página. Isso permite que uma página de dados seja gravada simultaneamente. O algoritmo de programação para a memória de dados EEPROM é o seguinte (para detalhes sobre Comandos, Endereços e Carga de dados, consulte Gravando a Memória Flash):
- A: Carregar o comando “0001 0001”;
- G: Carregar o byte alto de endereço (0x00-0FF);
- B: Carregar o byte baixo de endereço (0x00-0xFF);
- C: Carregar dados (0x00-0xFF);
- E: Reter os dados (dar um pulso positivo em PAGEL) ;
- K: Repetir de 3 a 5 até que todo buffer esteja cheio;
- L: Programar a página da EEPROM;
- L1: Definir BS1 em “0”;
- L2: Dar um pulso negativo em /WR. Isso inicia a gravação da página da EEPROM. RDY / /BSY fica em nível lógico baixo (busy) durante o processo;
- L3: Esperar até que RDY / /BSY fique em nível lógico alto (ready) antes de programar a próxima página (Veja a Figura 4 para as formas de onda).
Fonte: Datasheet do ATmega328P
Lendo a Memória Flash
O algoritmo de leitura da Memória Flash é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre a carga de Comandos e Endereços):
- A: Carregar o Comando “0000 0010”;
- G: Carregar o byte alto de endereço (0x00-0xFF);
- B: Carregar o byte baixo de endereço (0x00-0xFF);
- Definir /OE e BS1 em nível lógico baixo. O byte baixo da palavra da Flash agora pode ser lido em DATA (vide Tabela 1);
- Definir BS1 em nível lógico alto. O byte alto da palavra da Flash agora pode ser lido em DATA;
- Definir /OE em nível lógico alto.
Lendo a EEPROM
O Algoritmo de leitura da EEPROM é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre a carga de Comandos e Endereços):
- A: Carregar o Comando “0000 0011”;
- G: Carregar o byte alto do endereço (0x00-0xFF);
- B: Carregar o byte baixo do endereço (0x00-0xFF);
- Definir /OE e BS1’ em nível lógico baixo. O byte de dados da EEPROM agora pode ser lido em DATA (vide Tabela 1);
- Definir /OE em nível lógico alto.
Gravando os bits baixos de FUSE
O algoritmo de gravação dos bits altos de FUSE é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre Comandos e Carga de dados):
- A: Carregar o Comando “0100 0000”;
- C: Carregar o byte baixo de dados. Bit n=0 grava e bit n=1 apaga o bit de FUSE;
- Definir BS1 em nível lógico alto e BS2 em nível lógico baixo. Isto seleciona o byte alto de dados;
- Dar um pulso negativo em /WR e esperar que RDY / /BSY vá para nível lógico alto.
- Definir BS1 em nível lógico baixo. Isto seleciona o byte baixo de dados.
Gravando os bits estendidos de FUSE
O algoritmo de gravação dos bits estendidos de FUSE é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre Comandos e Carga de dados):
- A: Carregar o Comando “0100 0000”;
- C: Carregar o byte baixo de dados. Bit n=0 grava e bit n=1 apaga o bit de FUSE;
- Definir BS1 em nível lógico baixo e BS2 em nível lógico alto. Isto seleciona o byte estendido de dados;
- Dar um pulso negativo em /WR e esperar que RDY / /BSY vá para nível lógico alto.
- Definir BS2 em nível lógico baixo. Isto seleciona o byte baixo de dados.
Fonte: Datasheet do ATmega328P
Gravando os bits de Bloqueio
O algoritmo de gravação dos bits de bloqueio é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre Comandos e Carga de dados):
- A: Carregar o comando “0010 0000”;
- C: Carregar o byte baixo de dados. Bit n=0 bit de Bloqueio gravado. Se o modo LB3 for gravado (LB1 e LB2 são gravados), não é possível gravar os bits de Bloqueio de Boot por nenhum modo de Programação Externa.
- Dar um pulso negativo em /WR e esperar que RDY / /BSY vá para nível lógico alto.
Os bits de Bloqueio só podem ser apagados executando um “Chip Erase”.
Lendo os bits de FUSE e de Bloqueio
O algoritmo de gravação dos bits de bloqueio é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre Comandos e Carga de dados):
- A: Carregar o comando “0010 0000”;
- C: Carregar o byte baixo de dados. Bit n=0 bit de Bloqueio gravado. Se o modo LB3 for gravado (LB1 e LB2 são gravados), não é possível gravar os bits de Bloqueio de Boot por nenhum modo de Programação Externa.
- Dar um pulso negativo em /WR e esperar que RDY / /BSY vá para nível lógico alto.
Os bits de Bloqueio só podem ser apagados executando um “Chip Erase”.
Lendo os bits de FUSE e de Bloqueio
O algoritmo para ler os bits de FUSE e de Bloqueio é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre a carga de Comandos):
- A: Carregar o Comando “0000 0100”;
- Definir /OE; BS2 e BS1 em nível lógico baixo. O status dos bits baixos do FUSE podem agora ser lidos em DATA (0 indica gravado, 1 indica apagado);
- Definir /OE em nível lógico baixo e BS2 e BS1 em nível lógico alto. O status dos bits altos do FUSE podem agora ser lido em DATA;
- Definir /OE e BS1 em nível lógico baixo e BS2 em nível lógico alto. O status dos bits estendidos do FUSE podem agora ser lidos em DATA;
- Definir /OE e BS2 em nível lógico baixo e BS1 em nível lógico alto. O status dos bits de Bloqueio podem agora ser lidos em DATA;
- Definir /OE em nível lógico alto.
Fonte: Datasheet do ATmega328P
Lendo os bytes de Assinatura
O algoritmo para ler os bytes de Assinatura é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre a carga de Comandos e Endereços):
- A: Carregar o comando “0000 1000”;
- B: Carregar o byte baixo do Endereço (0x00 – 0x02);
- Definir /OE e BS1 em nível lógico baixo. O byte de assinatura selecionado agora pode ser lido em DATA.
- Defina /OE em nível lógico alto.
Lendo o byte de Calibração
O algoritmo para ler o byte de Calibração é o seguinte (consulte Gravando a Memória Flash para obter detalhes sobre a carga de Comandos e Endereços):
- A: Carregar o comando “0000 1000”;
- B: Carregar o byte baixo do Endereço, 0x00;
- Definir /OE em nível lógico baixo e BS1 em nível lógico alto. O byte de Calibração agora pode ser lido em DATA.
- Defina /OE em nível lógico alto.
Todo este segmento deste artigo se presta a fazer saber a maneira de programar um chip ATmega328P da forma que se conhece como Out System. A seguir o segmento que explicita a maneira In System de programar o chip.
Carga Serial
É descrito aqui como efetuar a programação e verificação serial da memória Flash de Programa, memória de dados EEPROM, FUSE bits, bits de Bloqueio de Memória, e bytes de Assinatura e Calibração do ATmega328P.
Denominação dos Sinais
Aqui alguns pinos do ATmega328P são referenciados por nomes de sinais que descrevem sua funcionalidade durante a programação serial. Consulte a Figura 7: Programação e Verificação Serial e a Tabela 6: Mapeamento por nomes de pinos na programação serial.
Fonte: Datasheet do ATmega328P
Notas:
- Se o chip for sincronizado pelo Oscilador interno, não é necessário conectar uma fonte de relógio em EXTCLK (pino XTAL1).
- (Vcc- 0,3V) < AVcc < (Vcc + 0,3V), no entanto, AVcc deve estar sempre entre 1,8 e 5,5V.
Ao gravar a EEPROM, um ciclo de apagamento automático é embutido na operação de autoprogramação (somente em modo serial) e não há a necessidade de primeiro executar a instrução “Chip Erase”. A operação “Chip Erase” transforma o conteúdo de cada posição de memória tanto de Programa (Flash), quanto EEPROM em 0xFF.
Dependendo do FUSE CKSEL, um sinal de relógio válido deve estar presente. Os períodos mínimos e máximos para a entrada de relógio serial (SCK) estão definidos da seguinte forma:
• Baixo: >2 ciclos de relógio de CPU para fck <12MHz, 3 ciclos de relógio de CPU para fck ≥ 12MHz
• Alto: >2 ciclos de relógio da CPU para fck <12MHz, 3 ciclos de relógio da CPU para fck ≥ 12MHz
Mapeamento de pinos da programação serial
| Sinal no Modo Programação | # pino do chip | Nome do pino do chip | Pino do Arduino | E/S | Função |
| MOSI | 17 | PB3 | D11 | E | Master Out Slave In (Entrada de dado serial) |
| MISO | 18 | PB4 | D12 | S | Master In Slave Out (Saída de dados serial) |
| SCK | 19 | PB5 | D13 | E | Serial Clock (relógio da comunicação serial) |
| XTAL1 | 9 | PB6 | — | E | Entrada de Relógio externo do ATmega328P |
| /RESET | 1 | PC6 | RESET | E | Reset do chip |
Fonte: Datasheet do ATmega328P
Algoritmo de Gravação Serial
Ao gravar dados seriais no dispositivo, os dados são sincronizados na borda de subida de SCK.
Ao ler dados do chip, os dados são sincronizados na borda de descida de SCK. Consulte a Figura 9 Formas de Onda da Gravação Serial na seção Características de Gravação Serial SPI para obter detalhes de temporização.
Para gravar e verificar o dispositivo no modo de carga serial, a seguinte sequência é recomendada (consulte a Instrução de carga serial definida na “Tabela 8. Conjunto de Instruções de Programação Serial”):
- Sequência de energização:
Aplicar a alimentação entre VCC e GND enquanto /RESET e SCK estiverem em nível lógico baixo. Em alguns sistemas, o programador não pode garantir que SCK seja mantido em nível lógico baixo durante a energização. Neste caso, o /RESET deve receber um pulso positivo de pelo menos dois ciclos de relógio da CPU após SCK ter sido definido em nível lógico baixo.
- Aguardar pelo menos 20ms e habilitar a carga serial enviando a instrução serial de Habilitação de Gravação para o pino MOSI.
- As instruções de carga serial não funcionarão se a comunicação estiver fora de sincronismo. Quando em sincronia. o segundo byte (0x53) ecoará de volta ao emitir o terceiro byte da instrução de habilitação de programação. Quer o eco esteja correto ou não, todos os quatro bytes da instrução devem ser transmitidos. Se o 0x53 não ecoou de volta, dar um pulso positivo no /RESET e emitir um novo comando de Habilitação de Gravação.
- A memória Flash é gravada uma página por vez. A página de memória é carregada um byte de cada vez, fornecendo 6 LSB (bits menos significativos) do endereço e dados junto com a instrução LPM (Load Program Memory Page). Para garantir a carga correta da página, o byte inferior de dados deve ser carregado antes do byte superior de dados ser aplicado a um determinado endereço. A Página de Memória de Programa é armazenada carregando a instrução WPM (Write Program Memory Page) com os 7 MSB (bits mais significativos) do endereço. Se a varredura (RDY / /BSY) não for usada, deve-se esperar pelo menos tWD_FLASH antes de enviar a próxima página. Acessar a interface de programação serial antes da conclusão da operação de gravação da Flash pode resultar em gravação incorreta.
- A: O arranjo EEPROM pode ser gravado um byte de cada vez, fornecendo o endereço e os dados junto com a instrução de escrita apropriada. Uma localização de memória EEPROM é primeiro apagada automaticamente antes de novos dados serem gravados. Se a varredura (RDY / /BSY) não for usada, deve-se esperar pelo menos tWD_EEPROM antes de enviar o próximo byte. Em um chip apagado, nenhum 0xFFs no(s) arquivo(s) de dados precisa ser gravado.
B: O arranjo EEPROM pode ser gravado uma página por vez. A página de memória é carregada um byte por vez, fornecendo 6 LSB do endereço e dados junto com a instrução LEM (Load EEPROM Memory Page). A página de memória EEPROM é armazenada carregando a instrução WEM (Write EEPROM Memory Page) com os 7 MSB do endereço. Ao usar o acesso à página EEPROM, apenas as localizações de bytes carregadas com a instrução LEM são alteradas. Os locais restantes permanecem inalterados. Se a varredura (RDY / /BSY) não for usada, deve-se esperar pelo menos tWD_EEPROM antes de enviar o próximo byte. Em um chip apagado, nenhum 0xFF no(s) arquivo(s) de dados precisa ser programado.
- Qualquer locação de memória pode ser verificada usando a instrução Read que retorna o conteúdo no endereço selecionado na saída serial MISO.
- No final da sessão de gravação, o /RESET pode ser definido em nível lógico alto para iniciar a operação normal.
- Sequência de desligamento (se necessário): Definir /RESET em nível lógico alto (“1”); desligar o VCC.
| Símbolo | Atraso Mínimo de Espera |
| tWD_FLASH | 2,6 ms |
| tWD_EEPROM | 3,6 ms |
| tWD_ERASE | 10,5 ms |
| tWD_FUSE | 4,5 ms |
Fonte: Datasheet do ATmega328P
Conjunto de Instruções de Gravação Serial
Aqui descreve-se o conjunto das instruções.
| Instrução / Operação | byte 1 | byte 2 | byte 3 | byte 4 |
| Habilitação de carga | 0xAC | 0x53 | 0x00 | 0x00 |
| Chip Erase (gravação de memória/EEPROM) | 0xAC | 0x80 | 0x00 | 0x00 |
| Varredura RDY / /BSY | 0xF0 | 0x00 | 0x00 | Dados (saída) |
| Instruções de carga | ||||
| Carrega byte de endereço estendido(1) | 0x4D | 0x00 | Endr Estendido | 0x00 |
| Carrega Página de Memória de Programa byte alto | 0x48 | 0x00 | Endr LSB | Dado Alto (entr) |
| Carrega Página de Memória de Programa byte baixo | 0x40 | 0x00 | Endr LSB | Dado Baixo (entr) |
| Carrega Página de EEPROM (acesso em página) | 0xC1 | 0x00 | 0000 000aa | Byte de dado |
| Instruções de Leitura | ||||
| Lê memória de programa (byte alto) | 0x28 | Endr MSB | Endr LSB | Dado Alto (saída) |
| Lê memória de programa (byte baixo) | 0x20 | Endr MSB | Endr LSB | Dado Baixo (saída) |
| Lê EEPROM | 0xA0 | 000000aa | aaaa aaaa | Dado (saída) |
| Lê bits de Bloqueio | 0x58 | 0x00 | 0x00 | Dado (saída) |
| Lê byte de Assinatura | 0x30 | 0x00 | 0000 000aa | Dado (saída) |
| Lê bits de FUSEs | 0x50 | 0x00 | 0x00 | Dado (saída) |
| Lê bits altos de FUSEs | 0x58 | 0x00 | 0x00 | Dado (saída) |
| Lê FUSEs Estendidos | 0x50 | 0x08 | 0x00 | Dado (saída) |
| Lê byte de Calibração | 0x38 | 0x00 | 0x00 | Dado (saída) |
| Instruções de Escrita (6) | ||||
| Escreve Página de Memória de Programa | 0x4C | Endr MSB (8) | Endr LSB (8) | 0x00 |
| Escreve na EEPROM | 0xC0 | 0000 00aa | aaaa aaaa | Dado (entr) |
| Escreve página de EEPROM (acesso de página) | 0xC2 | 0000 00aa | aaaa aa00 | 0x00 |
| Escreve bits de Bloquieo | 0xAC | 0xE0 | 0x00 | Dado (entr) |
| Escreve bits de FUSEs | 0xAC | 0xA0 | 0x00 | Dado (entr) |
| Escreve bits altos de FUSEs | 0xAC | 0xA8 | 0x00 | Dado (entr) |
| Escreve bits de FUSEs Estendidos | 0xAC | 0xA4 | 0x00 | Dado (entr) |
Fonte: Datasheet do ATmega328P
Obs.:
- Nem todas as instruções são aplicáveis a todas as peças.
- a = endereço.
- Os bits são programados em nível lógico baixo (‘0’), não programados em nível lógico (‘1’).
- Para garantir compatibilidade futura, FUSEs e bits de Bloqueio não utilizados devem ser não programados (mantidos em nível lógico alto – ‘1’).
- Consulte a seção correspondente para bits de FUSE e de bloqueio, bytes de Calibração e Assinatura e Tamanho da Página.
- As instruções de acesso à memória de programa usam um endereço de palavra. Este endereço pode ser aleatório dentro do intervalo de páginas.
- Consulte a internet para obter as notas de aplicação relacionadas à gravação e aos gravadores.
- PALAVRAS.
Se o byte de dados LSB em RDY / /BSY for ‘1’, uma operação de programação ainda está pendente. Espere até que este bit retorne ‘0’ antes que a próxima instrução seja executada.
Numa mesma página, o byte baixo de dados deve ser carregado antes do byte alto de dados.
Depois que os dados são carregados no buffer de página, programe a página EEPROM. Consulte a figura a seguir.
Fonte: Datasheet do ATmega328P
Características de Gravação Serial SPI
Fonte: Datasheet do ATmega328P
Maneiras
Fisicamente duas são as formas à disposição para gravar um Arduino Standalone, pela interface serial (UART), ou por ICSP (In Circuit Serial Programming – Programação serial no circuito em português), no entanto um Arduino Standalone não dispõe de uma porta de comunicação USB para ser conectado a um computador, tão pouco dispõe formalmente de um conector ICSP, logo nem um gravador USBasp tem serventia imediata.
Então para um Arduino Standalone restam duas alternativas: 1 – associar um conversor serial USB / TTL; ou 2 – efetuar as conexões equivalente do ICSP. Analisemos as duas alternativas.
Uso de conversor USB/TTL
Há diversas soluções de mercado para conversão serial USB / TTL, as mais frequentemente encontradas são 3 a saber: FTDI (Future Technology Devices International Ltd.) FT232; WCH CH340; e Silicon Labs CP2102.
Na Tabela 9: URL de download de drivers para conversores USB/TTL mais comuns, estão os URL dos fabricantes dos chips de conversão, onde pode-se efetuar o download para as plataformas Windows, Linux e Mac dos drivers dos seus respectivos produtos.
| Fabricante/Modelo | URL |
| FTDI / FT232 | https://ftdichip.com/drivers/d2xx-drivers/ |
| FTDI / FT232 | https://ftdichip.com/drivers/vcp-drivers/ |
| SiLabs / CP210x | https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers |
| WCH / CH340 | http://www.wch-ic.com/search?q=CH340&t=downloads |
Os módulos usando estas soluções podem ou não ter disponível o sinal DTR. Isto é importante de ser observado, pois sem este sinal conectado ao capacitor do pino de reset do Arduino Standalone, será necessária a intervenção manual, acionando o Reset, para que se reconheça a condição de tentativa de carga de código no ATmega328P, que de outra forma se dá automaticamente.
Esta solução é a de menor impacto e permite o uso do da IDE do Arduino na carga do código, ou mesmo o programa AVRdude (que na verdade é chamado pelo IDE do Arduino).
De forma generalista a conexões entre o módulo conversor USB / TTL e o Arduino Standalone são as relacionas na Tabela 10 a seguir.
| Módulo conversor | Arduino Standalone (ATmega328P) |
| GND | GND |
| VCC | +VCC (+5V) |
| TX | pino 2 (RX) |
| RX | pino 3 (RX) |
| DTR | Terminal livre do capacitor ligado ao pino 1 (/RESET) |
Lembrando que nem todos os módulos conversores têm todos os mesmos pinos, a tabela anterior relaciona os pinos necessários para a operação automática (sem intervenção humana) de carga de código.
No entanto, caso o ATmega328P usado no Arduino Standalone, não conte com o bootloader previamente gravado, esta maneira não terá serventia, uma vez que não há como inicializar a interface serial do ATmega328P para efetuar a recepção dos dados, tão pouco os processos de gravação do código na Flash, o que leva à necessidade do uso da próxima alternativa.
Uso do equivalente ao ICSP
Esta solução na verdade é baseada na capacidade SPI (Serial Peripheral Interface) nativa do ATmega328P, que é a base do ICSP.
Por meio de um protocolo de sinalização (conforme visto em Modos de Programação do ATmega328P – Carga Serial) é possível emitir comando de gravação/verificação das memórias Flash e EEPROM (além dos FUSEs do microcontrolador), independentemente de qualquer conteúdo preexistente em memória, o que permite inclusive a gravação do bootloader por conseguinte.
Para uso desta solução pode-se utilizar, entre outros, um gravador USBasp ou um segundo Arduino, no caso do Arduino Standalone por meio das ligações elétricas corretas.
Obs.: a possibilidade de gravadores aplicáveis é maior que a abordada aqui, portanto, o assunto não se limita em sua totalidade a esta análise, que percorre apenas os caminhos de mais baixo custo (entre 2 e 9 dólares).
O USBasp conta com um conector de dez pinos com as designações listadas na Tabela 11: Pinagem do ICSP do USBasp.
| Pino | Sinal | Pino | Sinal |
| 1 | MOSI | 2 | VCC |
| 3 | N.C. | 4 | |
| 5 | /RESET | 6 | |
| 7 | SCK | 8 | GND |
| 9 | MISO | 10 | GND |
As conexões do USBasp com o Arduino Standalone são como relacionadas na Tabela 12: Conexões USBasp X Arduino Standalone. Quando usado com Arduinos fabricados que contem com o conector ICSP, há no mercado adaptadores para converter os dez pinos do USBasp nos 6 dos Arduinos.
| Pino USBasp | Arduino Standalone (ATmega328P) | sinal |
| 2 | +5V | VCC |
| 8 ou 10 | GND | GND |
| 1 | pino 17 (PB3) | MOSI |
| 5 | pino1 (PC6) | /RESET |
| 7 | pino19 (PB5) | SCK |
| 9 | pino 18 (PB4) | MISO |
IMPORTANTE:
1 antes de fazer uso de um USBasp deve ser instalado o driver que pode ser encontrado em https://zadig.akeo.ie/ fazendo download do instalador de driver USB.
2 antes de fazer uso de um USBasp deve ser instalado o driver que pode ser encontrado em https://fischl.de/usbasp/ fazendo download do pacote mais recente, ao “desempacotar” (por exemplo usando o 7-zip), na pasta bin/win-driver/libusb_1.2.4.0 está o arquivo installer_x??.exe (pode ser 64 para sistemas Windows 64 bits, ou 32 para sistemas Windows 32 bits), que deve ser executado e ao plugar o USBasp no device manager, será encontrado o USBasp, sob libusb-win32 devices (provavelmente será necessário desabilitar a imposição de assinatura de driver, pois o driver baixado não é assinado digitalmente).
Uso de Arduino UNO (ou Nano)
Para realizar a gravação não é necessário usar um hardware exclusivo de gravador, com um segundo Arduino efetuando as conexões corretas é perfeitamente possível realizar a gravação do ATmega328P do Arduino Standalone.
No caso de uso de um Arduino UNO, as conexões entre os Arduinos Uno e Standalone são listadas na Tabela 13: Conexões Arduino UNO X Arduino Standalone.
Obs.: Em verdade as mesmas conexões podem ser usadas entre Arduinos UNO.
| Pino do UNO | Arduino Standalone (ATmega328P) | sinal |
| 5V | +5V | VCC |
| GND | GND | GND |
| 10 | pino 1 (PC6) | /RESET |
| 11 | pino 17 (PB3) | MOSI |
| 12 | pino 18 (PB4) | MISO |
| 13 | pino 19 (PB5) | SCK |
Sendo também uma alternativa de conexão usar o conector ICSP do Arduino, conforme indica a Figura 10: Conexões com o ICSP
Nesta situação utilizar o IDE do Arduino para efetuar a gravação é uma ótima solução pois todo o software necessário encontra-se disponível no próprio IDE.
Programas de Gravação do Standalone
Vistos os aspectos físicos, a circuitaria, das maneiras de gravação do Arduino Standalone, é chegado o momento de avaliar as possibilidades de software utilizável.
Como visto pode-se programar o Arduino Standalone na modalidade “In Circuit” pelo canal serial da UART do ATmega328P (desde que assessorado por um bootloader pré-gravado) ou pelo canal SPI pela conexão ICSP (ou equivalente).
Na Tabela 14: Possibilidades de software para gravação do Standalone vemos então as possibilidades seguintes:
| Modalidade | Hardware | Software |
| UART | USB | IDE |
| ICSP | USBasp | IDE AVRDude |
| ICSP | Segundo Aruino | IDE |
Na modalidade UART encontramos a situação padrão em que o trabalho é feito pelo bootloader que justamente é o oposto da situação que se tentamos cobrir aqui (a falta de bootloader).
Na modalidade ICSP encontra-se a possibilidade de uso de dois circuitos de gravação sendo um gravador de baixo custo o USBasp e o outro um Arduino (não considerando as possibilidades de modelos de Arduino).
ICSP com USBasp
Ao utilizar o USBasp como gravador é possível utilizar o IDE do Arduino como controlador, para tanto é necessário no menu Ferramentas, item Programador: selecionar a opção USBasp.
Para efetuar o envio do sketch atualmente carregado no IDE usa a opção “Carregar usando programador” do menu sketch.
Para gravar o bootloader é necessário adicionalmente selecionar o tipo de Arduino a receber o bootloader para então usar a opção “Gravar Bootloader” do menu Ferramentas.
No entanto, não contamos com um driver com assinatura digital disponível, então para poder usar o USBasp, é necessário primeiro desativar a obrigatoriedade de assinatura para o driver a ser instalado.
Sem o driver, ao plugar o USBasp o Gerenciador de dispositivos (Device Manager) nos apresenta a situação ilustrada na Figura 11 a seguir.
Que leva a constatação de que não há um drive de dispositivo instalado como confirma a Figura 12 na sequência.
Para resolver esta situação a primeira providência é baixar o ZADIG (https://zadig.akeo.ie/) um programa de instalação de drivers USB genéricos, que contorna o mecanismo de verificação de assinatura digital exigida pelo Windows.
O Zadig instala um entre quatro tipo de driver USB que são: WinUSB (libusb-1.0); libusb-win32; libusbK; e WinUSB (Microsoft). Em geral usar o driver libusbK traz resultados positivos com o USBasp.
Então uma vez feito o download execute o Zadig com direitos administrativos (usar o botão direito do mouse para obter o menu de contexto), como ilustra a Figura 13 a seguir.
Isso fará surgir a janela de Controle de Conta de Usuário, avisando que o aplicativo fará alterações em seu dispositivo o que deve ser permitido. Se for a primeira execução será perguntado se é desejável que o programa verifique se há atualizações, o que deve ser respondido da forma mais cômoda para o usuário. Em seguida a tela principal do programa é apresentada como mostrada na Figura14: Janela do Zadig.
Localize o USBasp na lista de dispositivos que o programa apresenta (Figura 15: Lista de dispositivos reconhecidos).
Na caixa de seleção em destaque na Figura 14 acima, selecione o driver libusbK e prema o botão Install Driver, logo abaixo da caixa de seleção. Aguarde a conclusão da instalação, que pode demorar um certo tempo.
Ao término da instalação do driver o USBasp será reconhecido como mostra a Figura 16: libusbK instalado.
E ao verificar os detalhes do driver instalado para o USBasp, obtemos o seguinte conjunto de informações como na Figura 17: Dados do driver instalado.
Deste ponto em diante o gravador USBasp é utilizável de imediato no IDE do Arduino ou com o avrdude e o AVRDUDESS, desde que este um destes esteja instalado no computador.
Usando com o IDE Arduino
Para usar o USBasp a partir do IDE do Arduino, é necessário primeiro fazer o IDE saber que vai trabalhar com este tipo de gravador entre tantos possíveis. Para tanto no menu Ferramentas do IDE encontra-se a opção Programador: que quando expandida nos mostra uma lista de possíveis programadores. Note que a lista pode ser razoavelmente longa, por exemplo, na instalação usada para o preparo deste trabalho, havia 15 modelos à escolha, entre eles está o USBasp, como visto na Figura 18: Menu Ferramentas / Programar
Uma vez selecionado o gravador, é chegada a hora de conectarmos o USBasp ao nosso Arduino Standalone, com a ajuda de cabos jumper e faremos a conexão através do flatcable (cabo plano) do gravador.
Na “Figura 19: Identificação de pinos do conector do USBasp” encontra-se uma tabela com a equivalência de 6 “sinais” onde conectar os jumperes macho-macho entre o cabo do USBasp e o Arduino Standalone. Esta conexão, por segurança, deve ser feita com o cabo desconectado do gravador.
A conexão pode resultar na aparência mostrada na Figura 20: Conexão Cabo USBasp com Arduino Standalone via jumperes.
Após feita e revisada a conexão pode-se conectar o cabo do gravador. Com isso o Arduino Standalone, será alimentado pelo USBasp, mas tenha em conta que como normalmente o USBasp tem um conector jumper que ou seleciona entre 3,3V e 5V, ou simplesmente desliga o 5V para o Arduino, a alimentação via fonte externa também é possível, bastando para tanto retirar tal jumper se disponível.
Uma vez o IDE configurado e o gravador devidamente conectado ao Arduino Standalone, agora é possível gravar tanto scketchs quanto o bootloader. No caso de efetuar a gravação de um scketch, por exemplo blink, que o exemplo clássico para o Arduino, deve-se inicialmente carregar o scketch através do menu Arquivo / Exemplos / 01.Basics / Blink, como ilustra a Figura 21.
Uma vez o sketch carregado no IDE, ao invés de utilizar a opção de menu Sketch / Carregar para enviar o código compilado, deve ser utilizada a opção Sketch / Carregar usando programador, como ilustra a Figura 22: Carga de código pelo programador.
Após comandar a carga do código, primeiro o IDE executará a compilação do sketch e uma vez sendo compilador sem erros, procede a ao envio do HEX resultando para o Arduino, quando será obtida no IDE na área de mensagens (janela de texto inferior do IDE) a seguinte saída:
O sketch usa 924 bytes (2%) de espaço de armazenamento para programas. O máximo são 32256 bytes.
Variáveis globais usam 9 bytes (0%) de memória dinâmica, deixando 2039 bytes para variáveis locais. O máximo são 2048 bytes.
C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude -CC:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf -v -patmega328p -cusbasp -Pusb -Uflash:w:B:\fjlopes\temp\arduino_build_50011/Blink.ino.hex:
avrdude: Version 6.3-20190619
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf"
Using Port : usb
Using Programmer : usbasp
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
eeprom 65 20 4 0 no 1024 4 0 3600 3600 0xff 0xff
flash 65 6 128 0 yes 32768 128 256 4500 4500 0xff 0xff
lfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
hfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
efuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
lock 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Programmer Type : usbasp
Description : USBasp, http://www.fischl.de/usbasp/
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.00s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: reading input file "B:\fjlopes\temp\arduino_build_50011/Blink.ino.hex"
avrdude: writing flash (924 bytes):
Writing | ################################################## | 100% 0.72s
avrdude: 924 bytes of flash written
avrdude: verifying flash memory against B:\fjlopes\temp\arduino_build_50011/Blink.ino.hex:
avrdude: load data flash data from input file B:\fjlopes\temp\arduino_build_50011/Blink.ino.hex:
avrdude: input file B:\fjlopes\temp\arduino_build_50011/Blink.ino.hex contains 924 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.47s
avrdude: verifying ...
avrdude: 924 bytes of flash verified
avrdude done. Thank you.
Já no caso da gravação do bootloader a operação será pela opção Ferramentas / Gravar Bootloader, garantindo antes ter selecionado a placa como “Arduino Uno”, conforme a Figura 23: Gravação de Bootloader.
Após comandar a gravação do Bootloader o IDE executará o envio do Bootloader preexistente na pasta da instalação do IDE, conforme o tipo de placa selecionado, no nosso caso Arduino UNO, obtendo na área de mensagens do IDE (janela de texto inferior do IDE) a seguinte saída:
C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude -CC:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf -v -patmega328p -cusbasp -Pusb -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xDE:m -Ulfuse:w:0xFF:m
avrdude: Version 6.3-20190619
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf"
Using Port : usb
Using Programmer : usbasp
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
eeprom 65 20 4 0 no 1024 4 0 3600 3600 0xff 0xff
flash 65 6 128 0 yes 32768 128 256 4500 4500 0xff 0xff
lfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
hfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
efuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
lock 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Programmer Type : usbasp
Description : USBasp, http://www.fischl.de/usbasp/
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.00s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: erasing chip
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: reading input file "0x3F"
avrdude: writing lock (1 bytes):
C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude -CC:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf -v -patmega328p -cusbasp -Pusb -Uflash:w:C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex:i -Ulock:w:0x0F:m
Writing | ################################################## | 100% 0.00s
avrdude: 1 bytes of lock written
avrdude: verifying lock memory against 0x3F:
avrdude: load data lock data from input file 0x3F:
avrdude: input file 0x3F contains 1 bytes
avrdude: reading on-chip lock data:
Reading | ################################################## | 100% 0.01s
avrdude: verifying ...
avrdude: 1 bytes of lock verified
avrdude: reading input file "0xFD"
avrdude: writing efuse (1 bytes):
Writing | ################################################## | 100% 0.00s
avrdude: 1 bytes of efuse written
avrdude: verifying efuse memory against 0xFD:
avrdude: load data efuse data from input file 0xFD:
avrdude: input file 0xFD contains 1 bytes
avrdude: reading on-chip efuse data:
Reading | ################################################## | 100% 0.00s
avrdude: verifying ...
avrdude: 1 bytes of efuse verified
avrdude: reading input file "0xDE"
avrdude: writing hfuse (1 bytes):
Writing | ################################################## | 100% 0.00s
avrdude: 1 bytes of hfuse written
avrdude: verifying hfuse memory against 0xDE:
avrdude: load data hfuse data from input file 0xDE:
avrdude: input file 0xDE contains 1 bytes
avrdude: reading on-chip hfuse data:
Reading | ################################################## | 100% 0.00s
avrdude: verifying ...
avrdude: 1 bytes of hfuse verified
avrdude: reading input file "0xFF"
avrdude: writing lfuse (1 bytes):
Writing | ################################################## | 100% 0.00s
avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0xFF:
avrdude: load data lfuse data from input file 0xFF:
avrdude: input file 0xFF contains 1 bytes
avrdude: reading on-chip lfuse data:
Reading | ################################################## | 100% 0.00s
avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude done. Thank you.
avrdude: Version 6.3-20190619
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf"
Using Port : usb
Using Programmer : usbasp
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
eeprom 65 20 4 0 no 1024 4 0 3600 3600 0xff 0xff
flash 65 6 128 0 yes 32768 128 256 4500 4500 0xff 0xff
lfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
hfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
efuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
lock 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Programmer Type : usbasp
Description : USBasp, http://www.fischl.de/usbasp/
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.01s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: reading input file "C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex"
avrdude: writing flash (32768 bytes):
Writing | ################################################## | 100% 0.00s
avrdude: 32768 bytes of flash written
avrdude: verifying flash memory against C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex:
avrdude: load data flash data from input file C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex:
avrdude: input file C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex contains 32768 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.00s
avrdude: verifying ...
avrdude: 32768 bytes of flash verified
avrdude: reading input file "0x0F"
avrdude: writing lock (1 bytes):
Writing | ################################################## | 100% 0.01s
avrdude: 1 bytes of lock written
avrdude: verifying lock memory against 0x0F:
avrdude: load data lock data from input file 0x0F:
avrdude: input file 0x0F contains 1 bytes
avrdude: reading on-chip lock data:
Reading | ################################################## | 100% 0.00s
avrdude: verifying ...
avrdude: 1 bytes of lock verified
avrdude done. Thank you.
Com isto grava-se o bootstrap no ATmega328P caso ele não o tenha, o que possibilita então o uso de um conversor USB/TTL conectado ao Arduino Standalone para carga de sketch, além do monitor serial, que não dependia do bootloader para funcionar.
Usando com o AVRDUDESS
Para utilizar o USBasp com o AVRDUDESS, obviamente este deve estar instalado e para tanto ele pode ser baixado de <https://blog.zakkemble.net/avrdudess-a-gui-for-avrdude/>, havendo uma versão instalável e uma portável para Windows e ambas necessitam do .NET Framework 2.0 SP1 ou posterior instalado na máquina.
Os códigos fonte estão disponíveis no GitHub em <https://github.com/zkemble/AVRDUDESS>.
O processo de instalação é bastante comum perguntando o idioma a ser usado na instalação, depois é solicitado o concordo com a licença, que é GNU versão 3, então sugere um local de instalação, e uma pasta para criar no local, por último pergunta se deseja que crie um atalho para executar o programa. Um resumo da instalação é apresentado e solicitada a autorização para iniciar o processo efetivo de instalação. Após a instalação é perguntado se é para executar o programa.
No entanto se não houver o .NET Framework 3.5, sua instalação poderá ser disparada neste ato. Eventualmente poderá ser necessário reiniciar o computador após a instalação do .NET
Uma vez pronto o ciclo de instalação ao dar um clique duplo no ícone do AVRDUDESS a tela mostrada será apresentada a tela conforme a Figura 24.
Inicialmente é necessário configurar qual o hardware de gravador estará em uso com o programa, neste caso o USBasp, como ilustra a Figura25 a seguir.
Com o gravador conectado ao computador e ao Arduino Standalone, é possível comandar a detecção de MCU, como exemplifica a Figura 26: Detecção de MCU.
Para enviar o código de um sketch para o Arduino Standalone, é necessário localizá-lo, o que pode ser feito interpretando as mensagens de saída do compilador. Uma vez localizado ele deve ser escrito, juntamente com o caminho no campo Flash, ou navegando com o botão com reticências à frente do campo Flash. Nos botões de rádio o botão Write deve estar selecionado e a caixa de formato deve estar marcando o formato compatível com o binário a ser gravado na memória (a saída de compilações resultante no IDE do Arduino é Intel Hex).
Caso seja necessário gravar algo na memória EEPROM, utilize o mesmo processo descrito acima.
Preparados todos estes passos premendo o botão Program! Inicia o processo de gravação do código no Arduino.
Para enviar o bootloader, um processo semelhante deve ser efetuado, com a diferença que o arquivo hex que nos interessa está localizado no seguinte caminho:
C:\Program Files (x86)\Arduino\hardware\arduino\avr\bootloaders\optiboot
Sendo o arquivo optiboot_atmega328.hex o que nos interessa.
Usando com o AVRDude
Para utilizar o USBasp com o avrdude, obviamente este deve estar instalado e para tanto ele pode ser baixado de <http://savannah.nongnu.org/projects/avrdude/>.
Por ser um programa de linha de comando, diversos parâmetros devem ser passados na sua chamada. Para ter uma lista das opções de chamada basta chamar o programa sem parâmetros e em tela obterá a saída a seguir.
C:>avrdude
Usage: avrdude [options]
Options:
-p <partno> Required. Specify AVR device.
-b <baudrate> Override RS-232 baud rate.
-B <bitclock> Specify JTAG/STK500v2 bit clock period (us).
-C <config-file> Specify location of configuration file.
-c <programmer> Specify programmer type.
-D Disable auto erase for flash memory
-i <delay> ISP Clock Delay [in microseconds]
-P <port> Specify connection port.
-F Override invalid signature check.
-e Perform a chip erase.
-O Perform RC oscillator calibration (see AVR053).
-U <memtype>:r|w|v:<filename>[:format]
Memory operation specification.
Multiple -U options are allowed, each request
is performed in the order specified.
-n Do not write anything to the device.
-V Do not verify.
-u Disable safemode, default when running from a script.
-s Silent safemode operation, will not ask you if
fuses should be changed back.
-t Enter terminal mode.
-E <exitspec>[,<exitspec>] List programmer exit specifications.
-x <extended_param> Pass <extended_param> to programmer.
-y Count # erase cycles in EEPROM.
-Y <number> Initialize erase cycle # in EEPROM.
-v Verbose output. -v -v for more.
-q Quell progress output. -q -q for less.
-l logfile Use logfile rather than stderr for diagnostics.
-? Display this usage.
avrdude version 6.3, URL: <http://savannah.nongnu.org/projects/avrdude/>
C: >
Na situação utilizada neste trabalho, a chamada pode ser a seguinte para gravar o bootloader já referido anteriormente (optiboot_atmeg328.hex) pode ser a seguinte:
avrdude -v -p m328p -c usbasp -Uflash:w:”C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex”:i
E será obtida a seguinte saída em tela:
avrdude: Version 6.3, compiled on Feb 17 2016 at 09:25:53
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Program Files (x86)\AVRDUDE\avrdude.conf"
Using Port : usb
Using Programmer : usbasp
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
eeprom 65 20 4 0 no 1024 4 0 3600 3600 0xff 0xff
flash 65 6 128 0 yes 32768 128 256 4500 4500 0xff 0xff
lfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
hfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
efuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
lock 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Programmer Type : usbasp
Description : USBasp, http://www.fischl.de/usbasp/
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.02s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: safemode: hfuse reads as DE
avrdude: safemode: efuse reads as FD
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: reading input file "C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex"
avrdude: writing flash (32768 bytes):
Writing | ################################################## | 100% 0.02s
avrdude: 32768 bytes of flash written
avrdude: verifying flash memory against C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex:
avrdude: load data flash data from input file C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex:
avrdude: input file C:\Program Files (x86)\Arduino\hardware\arduino\avr/bootloaders/optiboot/optiboot_atmega328.hex contains 32768 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.03s
avrdude: verifying ...
avrdude: 32768 bytes of flash verified
avrdude: safemode: hfuse reads as DE
avrdude: safemode: efuse reads as FD
avrdude: safemode: Fuses OK (E:FD, H:DE, L:FF)
avrdude done. Thank you.
Ou para gravar um sketch, por exemplo, o blink incluindo o bootloader para numa próxima carga poder usar o módulo conversor USB/TTL, com o seguinte comando (hipotético):
C:>avrdude -v -e -p m328p -c usbasp -Uflash:w:”B:\fjlopes\temp\arduino_build_674106/Blink.ino.with_bootloader.hex”:i
Obtendo a seguinte saída em tela, similar à anterior:
avrdude: Version 6.3, compiled on Feb 17 2016 at 09:25:53
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "C:\Program Files (x86)\AVRDUDE\avrdude.conf"
Using Port : usb
Using Programmer : usbasp
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
eeprom 65 20 4 0 no 1024 4 0 3600 3600 0xff 0xff
flash 65 6 128 0 yes 32768 128 256 4500 4500 0xff 0xff
lfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
hfuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
efuse 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
lock 0 0 0 0 no 1 0 0 4500 4500 0x00 0x00
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Programmer Type : usbasp
Description : USBasp, http://www.fischl.de/usbasp/
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.03s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: safemode: hfuse reads as DE
avrdude: safemode: efuse reads as FD
avrdude: erasing chip
avrdude: auto set sck period (because given equals null)
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: reading input file "B:\fjlopes\temp\arduino_build_674106/Blink.ino.with_bootloader.hex"
avrdude: writing flash (32768 bytes):
Writing | ################################################## | 100% 0.85s
avrdude: 32768 bytes of flash written
avrdude: verifying flash memory against B:\fjlopes\temp\arduino_build_674106/Blink.ino.with_bootloader.hex:
avrdude: load data flash data from input file B:\fjlopes\temp\arduino_build_674106/Blink.ino.with_bootloader.hex:
avrdude: input file B:\fjlopes\temp\arduino_build_674106/Blink.ino.with_bootloader.hex contains 32768 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.58s
avrdude: verifying ...
avrdude: 32768 bytes of flash verified
avrdude: safemode: hfuse reads as DE
avrdude: safemode: efuse reads as FD
avrdude: safemode: Fuses OK (E:FD, H:DE, L:FF)
avrdude done. Thank you.
ICSP com Arduino UNO (ou Nano)
Antes mesmo de estabelecer as conexões de hardware necessárias, com o Arduino que servirá de gravador, no próprio IDE do Arduino no menu Arquivo (File), na opção Exemplos (Examples), selecionar a alternativa Arduino ISP, como ilustra a Figura 27.
No menu Ferramentas (tools) selecionar a Placa (Board) Arduino UNO, no mesmo menu na opção Porta (Port) selecionar a porta de conexão do Arduino UNO.
Então com o menu Sketch na opção Carregar (Upload) fazer a carga do programa ArduinoISP.
O Arduino que desempenhará a função de gravador está preparado, agora é o momento de efetuar as conexões entre o Arduino UNO e o Standalone. Após estarem prontas no IDE menu Ferramentas, opção Programador “Arduino as ISP”, selecione Arduino as ISP, conforme ilustra a Figura 30: Seleção do modelo de gravador. Neste momento todo preparo para gravar algo no Arduino Standalone está concluído.
A partir daqui o trabalho é com o que se deseja gravar, para tanto no IDE deve-se abrir ou criar o sketch a ser gravado no Arduino Standalone normalmente e a seguir no menu Ferramentas opção Placa selecionar o modelo do Arduino destino da gravação que deve ser Arduino UNO, pois é nele que se baseia o Standalone.
Após isso no menu Sketch com a opção Carregar usando programador será feita a carga do sketch no Standalone através do Arduino UNO em uso como gravador, ilustrado na Figura 31.
Quando for o caso de gravar o bootloader, não é necessário carregar um sketch para gravar, basta no menu Ferramentas usar a opção Gravar Bootloader como ilustrado na Figura 32 e o bootloader compatível com a placa selecionada será gravado.
Considerações Finais
Como visto, este é um assunto repleto de detalhes muitos deles já simplificados por estarem equacionados em pacotes de hardware e software ao alcance por baixo custo, ou mesmo sem custo.
O projeto dos microcontroladores, pois isto não é exclusividade do ATmega328P, incorporar a capacidade de programação, no caso em modo serial, facilitada muito por dispensar hardwares específicos e especiais para gravação, possibilitando inclusive, atualizações de programação em campo.
Além de haver o fato de comprar microcontroladores pré-gravados levar a um encargo no custo de aquisição.
Assim ter a informação de como efetuar a gravação do microcontrolador do Arduino Standalone, é de grande relevância e dá muita autonomia ao usuário do Arduino.
Referências
Electronics Stackexchange. avr – AVRDUDE does not recognize USBasp device. Disponível em <https://electronics.stackexchange.com/questions/416714/avrdude-does-not-recognize-usbasp-device/417509#417509>, acessado em 05/jun./2021
FABRI JUNIOR, Luiz Ariovaldo. O Uso de Arduino na Criação de Kit para oficinas de robótica de baixo custo para escolas públicas. Limeira: [s.n.], 2014, p. 20
FISCHL. USBasp – USB programmer for Atmel AVR controllers. Disponível em <https://fischl.de/usbasp/>, acessado em 05/jun./2021
FONSECA, João Ledo. Computação Física. 2009. Disponível em <https://dreamfeel.wordpress.com/2009/03/07/computacao-fisica/>, acesso em 15 de set. de 2019.
FTDI. Driver para FTDI FT232 disponível em <https://ftdichip.com/drivers/d2xx-drivers/>, acesso em 24/ago./2021
FTDI. Driver para FTDI FT232 disponível em <https://ftdichip.com/drivers/vcp-drivers/>, acesso em 24/ago./2021
PENIDO, Édilus C. C.; TRINDADE, Ronaldo S. Microcontroladores. Ouro Preto: Instituto Federal de Educação, Ciência e Tecnologia de Minas Gerais. 2013. 80 p. il. 28cm
SiLabs. Driver para SiLabs CP210x disponível em <https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers>, acesso em 24/ago./2021
Texas Instruments. Disponível em <https://web.archive.org/web/20051105012050/http://www.ti.com/corp/docs/company/history/microcomputer.shtml> acessado em 05/jun./2021
WCH. Driver para WCH CH340 disponível em <http://www.wch-ic.com/search?q=CH340&t=downloads>, acesso em 24/ago./2021
Zadig. Zadig – USB driver installation made easy. Disponível em <https://zadig.akeo.ie/>, acessado em 05/jun./2021
Glossário
Arduino Standalone É a montagem que replica o funcionamento básico de um Arduino geralmente a paritr de um chip microcontrolador ATmega328P e um mínimo de componentes adicionais.
Bootloader Programa inicializador com o objetivo de preparar o hardware para o seu correto funcionamento
FUSE Bits de configuração utilizado em microcontroladores para definir o modo de operação de divewrsos periféricos e recursos internos do chip.
High Voltage Parallel Programming (Programação Paralela de Alta Tensão), método de gravação possível para microcontroladores.
ISP In System Programming (Programação no Sistema), método de gravação que utiliza serialização dos dados a serem gravados em microcontroladores.
Memória FLASH Dispositivo de armazenamento não volátil da família das EEPROM criado pelo Dr. Fujiio Masuoka na Toshiba nos anos 1980, ou seja que pode ser re-escrito, como fosse uma RAM. Seu nome vem do fato de o apagamento ser tão rápido quanto um flash fotográfico, por apagar blocos de posições de memória simultaneamente.
Memória EEPROM Electrically-Erasable Programmable Read-Only Memory (Memória programável apenas de leitura eetricamente apagável), também conhecida como E²PROM é um tipo de memória não volátil usado para armazenar pequenos programas ou pequenas quantidades de dados.
Sketch Em português esboço, é o programa a ser compilado re carregado no Arduino, recebendo esta denominação por se tratar de uma placa protótipo, fazendo referência a ser um esboço de projeto.
SPI Serial Peripheral Interface (Interface Serial de Periféricos), disciplina de comunicação serial de alta velocidade e curta distância concebida pela Motorola nos anos 70.
USBasp É um gravador para microcontroladores Atmel AVR com uma conexão USB construída em sua placa.
Lista de Abreviaturas e Siglas
ARM Acorn RISC Machine (Máchina RISC Acorn) ou Advanced RISC Machine (Máquina RISC Avançada)
AVcc Analogic Volts Continous Current (Tensão de Corrente Continua Analógica)
BSY Busy, ocupado em inglês
CKSEL Clock Select, Seleção de Relógio em português
COM Communicator (Comunicador)
DTR Data Terminal Ready (Terminal de Dados Pronto)
EEPROM Eletricaly Erasable Programmable Read Only Memory (Memória Apenas de Leitura Programável Eletricamente Apagável)
EESAVE Electric Erase Save,
FTDI Future Technology Devices International
GND Ground (Terra)
ICSP In Circuit Serial Programming (Programação Serial no Circuito)
IDE Integrated Development Environment (Ambiente de Desenvolvimento Integrado)
ISP In System Programmer (Programador no sistema)
k Kilo
LEM Mnemônico da instrução Load EEPROM Memory Page (Carga da Página de Memória EEPROM)
LPM Mnemônico da instrução Load Program Memory (Carga da Memória de Programa)
LSB Least Significant Bit ou Least Significant Byte, bit ou byte (dependendo do contexto) menos significativo em inglês
M Mega
MHz MegaHertz
MISO Master Input Slave Output, Entrada do Mestre Saída do Escravo em inglês
MOSI Master Output Slave Input, Saída do Mestre Entrada d Escravo em inglês
ms milissegundo
MSB Mst Singnificant Bit ou Most Significante Byte, bit ou byte (dependendo do contexto) mais significativo em inglês
N.C. Not Connected, não conectado em inglês
NOP No Operation, sem operação em inglês
OE Output Enable, habilitação de saída em inglês
RDY Ready, pronto em inglês
RX Receptor ou recepção
SCK Serial Clock
SPI Serial Peripheral Interface
TTL Transistor Transistor Logic (Lógica Transistor Transistor)
TX Transmissor ou transmissão
UART Universal Assincronous Receiver and Transiver (Receptor e Transmissor Sincrono e Assincrono Universal)
ULSI Ultra Large Scale Integration (Ultra Alta Escala de Integração)
ms microsegundo
USART Universal Sincronous and Assincronous Receiver and Transiver (Receptor e Transmissor Sincrono e Assincrono Universal)
USB Universal Serial Bus (Barramento Serial Universal)
V Volts
Vcc Volts Continous Current (Tensão de Corrente Continua Analógica)
WEM Write EEPROM Memory, Escrita em memória EEPROM
WPM Write Programmable Memory, escrita em memória de programação
WR Write, escrita em inglês
XTAL Cristal