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.

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)

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:

1. 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;
2. 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;
3. Aguardar de 20 a 60μs e aplicar de 11,5 a 12,5V no pino /RESET;
4. 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;
5. Esperar por ao menos 300μs antes de emitir qualquer comando da programação paralela;
6. 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:

1. 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;
2. Aplicar de 4,5 a 5,5V entre Vcc e GND;
3. Monitorar Vcc, e assim que atingir 0,9 a 1,1V, aplicar de 11,5 a 12,5V no pino /RESET;
4. 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;
5. Esperar até Vcc realmente alcançar entre 4,5 e 5,5V antes de emitir qualquer comando da programação paralela;
6. 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

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

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

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⁽¹⁾, 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:

1. Carga do comando “Gravar a Flash”
   1. Ajustar XA1 e XA0 para “10”. Isto habilita a carga de comando;
   1. Ajustar BS1 para “0”;
   1. Ajustar os dados para “0001 0000”. Isto é o comando de “Gravar a Flash”;
   1. Dar um pulso positivo em XTAL1. Isto carrega o comando.
2. Carga do byte baixo do endereço
   1. Ajustar XA1 e XA0 para “00”. Isto habilita a carga do endereço;
   1. Ajustar BS1 para “0”. Isto seleciona o endereço baixo;
   1. Ajustar os dados com o byte baixo do endereço (0x00-0xFF);
   1. Dar um pulso positivo em XTAL1. Isto carrega o byte baixo do endereço.
3. Carga do byte baixo de dados
   1. Ajustar XA1 e XA0 para “01”. Isto habilita a carga de dados;
   1. Ajustar os dados com o byte baixo de dados (0x00-0xFF);
   1. Dar um pulso positivo em XTAL1. Isto carrega o byte de dados.
4. Carga do byte alto de dados
   1. Ajustar BS1 para “1”. Isto seleciona o byte alto de dados;
   1. Ajustar XA1 e XA0 para “01”. Isto habilita a carga de dados;
   1. Ajustar os dados com o byte alto de dados (0x00-0xFF);
   1. Dar um pulso positivo em XTAL1. Isto carrega o byte de dados;
5. Trava dos dados
   1. Ajustar BS1 para “1”. Isto seleciona o byte alto de dados;
   1. Dar um pulso positivo em PAGEL. Isto trava os bytes de dado (Veja a Figura 2 para formas de onda dos sinais).
6. 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

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):

1. A: Carregar o comando “0001 0001”;
2. G: Carregar o byte alto de endereço (0x00-0FF);
3. B: Carregar o byte baixo de endereço (0x00-0xFF);
4. C: Carregar dados (0x00-0xFF);
5. E: Reter os dados (dar um pulso positivo em PAGEL) ;
6. K: Repetir de 3 a 5 até que todo buffer esteja cheio;
7. L: Programar a página da EEPROM;
8. L1: Definir BS1 em “0”;
9. 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;
10. 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).

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):

1. A: Carregar o Comando “0000 0010”;
2. G: Carregar o byte alto de endereço (0x00-0xFF);
3. B: Carregar o byte baixo de endereço (0x00-0xFF);
4. 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);
5. Definir BS1 em nível lógico alto. O byte alto da palavra da Flash agora pode ser lido em DATA;
6. 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):

1. A: Carregar o Comando “0000 0011”;
2. G: Carregar o byte alto do endereço (0x00-0xFF);
3. B: Carregar o byte baixo do endereço (0x00-0xFF);
4. 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);
5. 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):

1. A: Carregar o Comando “0100 0000”;
2. C: Carregar o byte baixo de dados. Bit n=0 grava e bit n=1 apaga o bit de FUSE;
3. Definir BS1 em nível lógico alto e BS2 em nível lógico baixo. Isto seleciona o byte alto de dados;
4. Dar um pulso negativo em /WR e esperar que RDY / /BSY vá para nível lógico alto.
5. 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):

1. A: Carregar o Comando “0100 0000”;
2. C: Carregar o byte baixo de dados. Bit n=0 grava e bit n=1 apaga o bit de FUSE;
3. Definir BS1 em nível lógico baixo e BS2 em nível lógico alto. Isto seleciona o byte estendido de dados;
4. Dar um pulso negativo em /WR e esperar que RDY / /BSY vá para nível lógico alto.
5. Definir BS2 em nível lógico baixo. Isto seleciona o byte baixo de dados.

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):

1. A: Carregar o comando “0010 0000”;
2. 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.
3. 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):

1. A: Carregar o comando “0010 0000”;
2. 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.
3. 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):

1. A: Carregar o Comando “0000 0100”;
2. 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);
3. 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;
4. 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;
5. 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;
6. Definir /OE em nível lógico alto.

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):

1. A: Carregar o comando “0000 1000”;
2. B: Carregar o byte baixo do Endereço (0x00 – 0x02);
3. Definir /OE e BS1 em nível lógico baixo. O byte de assinatura selecionado agora pode ser lido em DATA.
4. 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):

1. A: Carregar o comando “0000 1000”;
2. B: Carregar o byte baixo do Endereço, 0x00;
3. 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.
4. 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.

Notas:

1. Se o chip for sincronizado pelo Oscilador interno, não é necessário conectar uma fonte de relógio em EXTCLK (pino XTAL1).
2. (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 f_ck <12MHz, 3 ciclos de relógio de CPU para f_ck ≥ 12MHz

• Alto: >2 ciclos de relógio da CPU para f_ck <12MHz, 3 ciclos de relógio da CPU para f_ck ≥ 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

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”):

1. Sequência de energização:

Aplicar a alimentação entre V_CC 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 t_{WD_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 t_{WD_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 t_{WD_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 V_CC.

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

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)

Obs.:

1. Nem todas as instruções são aplicáveis a todas as peças.
2. a = endereço.
3. Os bits são programados em nível lógico baixo (‘0’), não programados em nível lógico (‘1’).
4. 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’).
5. Consulte a seção correspondente para bits de FUSE e de bloqueio, bytes de Calibração e Assinatura e Tamanho da Página.
6. 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.
7. Consulte a internet para obter as notas de aplicação relacionadas à gravação  e aos gravadores.
8. 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.

Características de Gravação Serial SPI

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