Tutorial Gravador de AT89S52

Tutorial Gravador de AT89S52
Introdução
Neste tutorial o intuito é mostrar a montagem e funcionamento de um gravador de
E2PROM. Este gravador permite o programador transferir seus códigos compilados
para a memória Flash do micro controlador (MC) AT89S52.
O projeto do circuito, montado em uma protoboard, funciona para a maioria dos
programas gravadores atualmente disponíveis na internet, como por exemplo o: ISPFlash Programmer 3.0 criado pelo Muhammad Assim Khan.
Eu utilizei esse circuito para a criação do meu programa de gravação. Este programa eu
chamei de Flash51. Foi desenvolvido em C++. Para efeitos de aprendizagem, neste
tutorial utilizaremos Visual Basic 6 (VB6) e eu mostrarei apenas o funcionamento
básico da programação. Cabe a você leitor debruçar sobre os manuais dos MC’s e criar
seus próprios programas gravadores.
Objetivo
Montar circuito para gravação de memória flash do micro controlador AT89S52.
Escrever um programa de exemplo capaz de estabelecer uma comunicação com o MC e
fazê-lo responder de acordo. O código contido neste tutorial apenas executa um
comando de iniciação (Programming Enable) e força o MC a responder uma palavra.
Dessa forma, poderemos testar a capacidade do MC entender um comando e responder,
estabelecendo um cumprimento (hand-shaking). Este exemplo apenas funciona no
micro AT89S52 e não funcionará para outros MCs, pois cada micro tem suas frases de
programação e timmings de comunicação.
Montar um cabo para comunicação entre o computador, via porta paralela, e o MC, via
ISP.
Índice
Tutorial Gravador de AT89S52.......................................................................................... 1
Introdução...................................................................................................................... 1
Objetivo......................................................................................................................... 1
Índice............................................................................................................................. 2
Passo-A-Passo............................................................................................................... 6
Montagem do Circuito............................................................................................... 6
Montagem do cabo.................................................................................................. 19
O Programa Gravador de E2PROM............................................................................ 20
Entendendo o Sistema de Gravação........................................................................ 21
Lógica do Programa................................................................................................. 25
O Código Completo................................................................................................. 29
Conclusões................................................................................................................... 33
Material Necessário
Tabela de materiais.
4 Conjuntos de
LED + Resistor
1,2k ohms
1 Capacitor
Eletrolítico
220uF – 25V
1 Capacitor de
Cerâmica 100nF
(104)
2 Capacitores de
Cerâmica 33pF
(33)
1 Cristal de
12Mhz ou
11,0592Mhz
1 Diodo 1N4007
1 Regulador de
Tensão LM7805
1 Ponte Com 5
Terminais
1 Micro
Controlador
AT89S52 (com
soquete)
1 Terminal
Fêmea Para
Fonte de
Alimentação
1 Fonte de
alimentação 9V
1 LED Verde
1 Resistor de
100 ohms
1 Protoboard
para montagem
do circuito (já
grampeada para
conectar as 3
linhas de energia
entre si)
Fios variados de
cobre duro e
grampos para a
ligação dos
componentes.
Passo-A-Passo
Montagem do Circuito
Tabela de instruções da montagem.
Não existe
conexão entre os
dois lados.
Para quem não conhece uma protoboard, note que ela tem linhas horizontais (exemplo
em amarelo) de conexão para os componentes e linhas verticais de força (exemplos em
vermelho e azul), que garantem alimentação aos circuitos. Repare também que nas
linhas de força existem marcações em azul para o negativo e vermelho para o positivo.
Antes de tudo vale a pena verificar a tensão da fonte de alimentação e sua polaridade.
+
–
Ligue os fios vindos da fonte de alimentação conforme a foto, na primeira linha de
montagem dos componentes, no buraco mais exterior e com o negativo para o lado
direito.
Grampeie a placa na parte inferior para fazer as conexões entre as linhas de força.
Agora faça um grampo entre o negativo vindo da fonte para o negativo da linha de
força central.
Ligue o capacitor cerâmico de 100nF entre o positivo e o negativo da linha de
alimentação lateral.
Agora coloque o diodo 1N4007 na linha do positivo da fonte e outra linha mais abaixo.
Verifique o sentido do componente, a faixa prata deve ficar para o lado oposto do
positivo da fonte.
Para conectar o LM7805, que é o regulador responsável por fornecer 5V para o
circuito, olhando por trás (conforme na foto) deve-se ligar o pino mais a direita na
mesma linha do diodo.
O pino do meio do LM7805 deve ser ligado no negativo da linha de força.
A perna mais a esquerda (ainda tomando como base a visão por trás) deve ser
grampeada no positivo da linha de força.
Voltando a perna da direita do LM7805, devemos conectar o capacitor eletrolítico.
Ligue o positivo do capacitor na linha da perna da direita do regulador e o negativo, no
negativo da linha de força lateral. Atenção para a polaridade do capacitor. Faixa
prateada para o negativo.
Para terminar a montagem do circuito da fonte de alimentação, coloque o LED verde e
o resitor de 100 ohms como mostrado na foto. Aproveite uma linha de componentes
que está desligada e monte a perna do LED que não tem o chanfro. Monte também
nessa linha uma das pernas do resistor. Depois conecte a parte chanfrada do LED no
negativo da linha de força e a outra perna do resistor no positivo da linha de força.
Coloque então o micro controlador em outra área de componentes, do lado direito da
linha central de força.
Grampeie o pino 40 do AT89S52 no positivo da linha de força. Veja que o pino 40 é o
primeiro da direita.
Nos dois pinos antepenúltimos da esquerda, XTAL1 e XTAL2, conecte o cristal.
Aproveite as linhas do cristal para conectar os capacitores eletrolíticos de 33pF. Uma
perna de cada capacitor nas linhas das pernas do cristal. Ligue a outra perna dos
capacitores no negativo da linha de força.
Grampeie o negativo do MC. Última perna da esquerda no negativo da linha de força.
Ligue o pino 31 (EA/) no positivo da linha de força. Isso fará com que o controlador
execute o código da memória interna do MC.
Conecte a ponte com cinco terminais nas linhas da direita da parte a esquerda da linha
de força central, na protoboard, conforme mostra a foto. Depois eu descobri que é
melhor colocar mais a direita ainda, mas por ora vamos deixar aí.
Vamos ligar o MOSI, que é o pino 1 do conector e o 6 do MC, na porta P1.5. Esse pino
é responsável por receber os dados enviados pelo PC.
O segundo pino do conector é ligado no pino 9 do MC, que é o Reset. Na hora da
programação, ele é conhecido como Enable (EN), responsável por “dizer” ao micro
controlador que o PC vai enviar informações.
O pino 3 do conector é ligado ao MISO do micro, que é o pino 7, porta P1.6. Esse pino
é responsável pela parte de envio de dados do MC para o PC, caminho inverso do
MOSI.
O quarto pino do conector de 5 pinos é o SCK, que é ligado no pino 8 do MC, na porta
P1.7. Ele é responsável por sincronizar a comunicação, enviando um pulso que forma
uma onda quadrada, para sincronizar os dois dispositivos se comunicando, ou seja, o
MC e o PC.
GND
SCK
MISO
EN
MOSI
Pino 1
O pino 5, último do conector, é ligado no negativo da linha de força. Repare também
que eu reposicionei a barra de pinos, que se você ainda não notou é o nosso conector.
Eu sei que não se parece com um, mas é onde vamos conectar o cabo de dados que vai
ligado na outra ponta: o PC, pela porta paralela.
Para finalizar, ligamos os LEDs vermelhos e seus resistores de 1K2 ohms. Conecte a
parte com chanfro no negativo da fonte e a outra perna no pino correspondente. O
primeiro ligado na foto é o do pino 4, o CLK.
Depois ligue o LED do pino 3, invertido, com o conector achatado do LED na linha do
pino e a outra perna do resistor no positivo da linha de força. Termine conectando os
outros dois conjuntos de LEDs como foi feito no primeiro. Estes que faltam são os
pinos 2 e 1, Enable e MOSI, respectivamente.
Com isso terminamos a parte da montagem do circuito do gravador.
Montagem do cabo
Tabela de instruções da montagem.
Não vou me prender muito na montagem do cabo de dados. Vou apenas dizer que o
conector que vai ligado no PC é um DB25 macho. Na outra ponta, o conector deve ser
fêmea, compatível com a barra de pinos. Facilmente encontrada nas melhores casas do
ramo. A fita preta do acabamento é isolante termo-ativado.
Mapeamento dos Pinos
Tabela de mapeamento de pinos entre os conectores.
Pino
MOSI
EN
MISO
SCK
GND
DB25 (porta paralela)
7
9
10
6
25
Conector ISP
1
2
3
4
5
Obs: Existe uma ligação entre os pinos 2 e 12 do conector da porta paralela, que
somente é necessária para o funcionamento em outros programas de gravação, como
citado anteriormente: ISP-Flash Programmer 3.0 criado pelo Muhammad Assim Khan.
O Programa Gravador de E2PROM
Eu desenvolvi um gravador em C++. Eu preferi utilizar essa linguagem por ela ter uns
tratamentos mais elegantes no deslocamento de bits, entre outras características. Mas
para esse tutorial decidi escrever um fragmento de código especialmente em VB6. A
razão disso é simples: o intuito desse tutorial é mostrar o processo de gravação de dados
na memória Flash do micro controlador e não explicar recursos complicados de
linguagens de programação. Por isso o VB6 cai como uma luva para não perdermos o
foco.
O importante é entender o processo de gravação. O resto vem fácil. Na verdade não vou
mostrar o processo de gravação em si, mas sim o caminho para tal. O que vamos fazer é
enviar uma instrução inicial de programação para estabelecer comunicação. É como se
fosse uma verificação rápida de que todos os componentes foram montados
corretamente e que não há problemas na comunicação entre o PC e o MC.
Para aprender a montar a programação restante do programa de gravação, você
precisará estudar o datasheet do AT89S52 e ler as partes referentes à Serial
Programming.
Esse método de programação é chamado de In-System Programming (ISP), também
conhecido como Serial Programming Interface (SPI). Neste método, temos frases de 4
bytes que devem ser enviadas para o MC em forma de comandos. Existem comandos
para apagar a memória Flash do micro, escrever dados, ler dados, habilitar programação
(Programming Enable – é este que vamos estudar) e ler e escrever dados em forma de
página de dados.
Existem ainda fusíveis programáveis, mas ainda não estudei sobre eles.
Todas essas funcionalidades eu vou disponibilizar no meu programa chamado Flash51.
Aqui vou apenas mostrar o caminho para você poder fazer igual, ou melhor!
Entendendo o Sistema de Gravação
O básico que precisamos saber é que para se comunicar com esse MC em específico,
temos que enviar 4 bytes em uma velocidade inferior a 1/16 do clock do micro
controlador.
Como estamos utilizando um cristal de 12Mhz, temos que enviar mais devagar que
750.000 ciclos por segundo. Na verdade isso já é bem rápido para os nossos padrões de
comunicação. Se enviarmos dados a uma taxa de mil ciclos por segundo já estaremos
bem mais devagar e fica mais fácil fazer cálculos.
Veja bem, para ficar bem claro esse assunto, vamos fazer uns cálculos:
12Mhz / 16 = 750KHz
Então temos 750 mil ciclos por segundo, isso nos dá:
1 segundo / 750KHz = 0,00000134 segundos.
Temos que ser mais lentos que 1 ciclo a cada 0,00000134 segundos. Não parece ser
muito difícil ser mais lento que isso! Ainda bem que não é ao contrário!
O ideal seria trabalharmos com algo em torno de meio milissegundo por ciclo. Faria o
programa gravador ficar mais rápido e mais eficiente. Mas como no VB6 trabalhar com
temporizadores é meio complicado, optei por uma solução bem caseira. Um loop vazio
para atrasar o processamento o suficiente para criar o pulso da comunicação.
Vamos rever algumas etapas da comunicação:
•
•
•
•
Levantar o estado lógico do pino 9 da porta paralela para habilitar o
envio de dados e comandos para o micro controlador;
Criar uma onda quadrada para sincronia da comunicação, utilizando o
pino 6 da porta paralela, em uma velocidade menor que 1 pulso a cada
0,00000134 segundos.
Enviar os dados pelo pino 7 da porta paralela.
Receber os dados pelo pino 10 da porta paralela.
Pronto, assim estabelecemos comunicação!
Se você ainda não entendeu muito bem a forma de envio é porque você precisa estudar
comunicação serial. Veja que não vamos passar os 4 bytes diretamente para o micro
controlador. Cada byte tem 8 bits e nós só temos um fio para enviar e um para receber,
além do sinal de sincronismo e do enable que é o interruptor geral.
Então o que precisamos fazer é enviar cada bit pelo pino do MOSI em sincronia com o
pino do SCK. E no momento apropriado, ler os bits chegando ao pino MISO.
Os tempos que essas ações devem ocorrer seguem o padrão da figura abaixo:
(Desculpem o desenho)
Sendo que as linhas pretas representam o pulso do clock, e as linhas vermelhas
representam o canal de dados. Veja bem, não é porque existem duas linhas vermelhas se
cruzando, que significa que são realmente dois canais de comunicação. O canal é um só,
mas as duas linhas representam o estado do canal naquele dado momento. E esse canal
pode ter um de dois estados ao mesmo tempo, por isso duas linhas.
Portanto, quando temos um sinal alto no clock, a linha preta está na sua parte mais alta,
e se mantém lá por um período de tempo. Depois desse tempo devemos colocar valor
baixo no pino do clock por mais um tempo, que deve ser o mesmo em que o clock ficou
em alto. Repetindo esse ciclo indefinidamente, temos o sinal de sincronismo que nada
mais é senão um tipo de marca-passo.
Veja que as linhas vermelhas estão se cruzando para mostrar quando deve haver troca de
informação no canal de dados. Se a informação for alterada no canal, fora desses
intervalos indicados, onde podemos ver a intersecção das linhas vermelhas, o MC vai se
perder na comunicação.
Bom, o importante desse desenho é verificar que os dados são realmente enviados
enquanto o clock está em alto e que quando o clock está em baixo é a hora de mudar a
informação no canal de dados, se for necessário.
Outra coisa importante a se saber é que os bytes são enviados pelo canal de dados pelo
bit mais significativo. A seqüência deve ser ao contrário, conforme a figura abaixo:
Sentido da comunicação
PC
0←1←2←3←4←5←6←7
MC
Sentido do envio dos bits
Bom, para irmos para a parte prática, precisamos primeiro estudar a frase que vamos
enviar para o micro.
Tabela do código binário do comando Programming Enable.
Habilita Programação Serial enquanto o EN está em alto.
Sentido de Envio:
Byte 1
Byte 2
Byte 3
Byte 4
1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1 X X X X X X X X X X X X X X X X
0 1 1 0 1 0 0 1
Resposta do MC
Resumindo, precisamos enviar uma sequência 10101100 e depois 01010011. Com isso
o MC entende que estamos enviando um comando. O byte 3 não importa para esse
comando, então enviamos qualquer informação. Vamos enviar sempre zero quando os
bits não importarem.
O último byte também não importa, mas o interessante é que no timming desse byte, o
MC responde a aceitação do comando. Mais ou menos como um: Entendido!
Para enviar os bits pela porta paralela, precisamos estabelecer um ciclo. O ciclo do
envio dos bytes deve ser:
•
•
•
•
•
•
Envia o bit mais significativo junto com o sinal de clock*;
Espera mais ou menos 1 milissegundo;
Envia o bit como zero junto com o sinal de clock em baixo;
Espera mais ou menos 1 milissegundo;
Repete seqüência para o próximo bit até o oitavo bit;
Repete seqüência para o próximo byte.
* Aqui tem um truque. Se o bit for 1, é preciso enviar antes para a porta para só então
ligar o clock. Se for enviado no mesmo comando, ele leva uma fração de segundo a
mais que o clock para ligar e o MC entende errado. Se o bit for 0 não tem problemas.
Bom, para enviar dados pela porta paralela, precisamos escrever no buffer de dados,
chamado Data Register. Os bits desse buffer que nos interessam são o D7 (MOSI), o D5
(EN) e o D4 (MISO). Portanto para enviar as combinações que precisamos, temos a
tabela a seguir:
Tabela do registrador de dados da porta paralela.
EN
EN+MOSI
EN+SCK
EN+MOSI+SCK
D7
1
1
1
1
D6
0
0
0
0
D5
0
1
0
1
D4
0
0
1
1
D3
0
0
0
0
D2
0
0
0
0
D1
0
0
0
0
D0
0
0
0
0
Hex.
80
A0
90
B0
Dec.
128
160
144
176
E para ler do buffer de entrada, chamado Status Register, temos que acompanhar a
tabela abaixo para entender qual bit precisamos pegar, pois o bit que nos interessa é o
que vem do pino do MISO, que é o Ack do buffer:
Tabela do registrador de status da porta paralela.
S0
X
X
S1
X
X
S2
X
X
S3
X
X
S4
X
X
S5
X
X
S6
1
0
S7
X
X
Hex.
5F
1F
Dec.
95
31
Essa tabela é mais simples. Difícil mesmo é tratar o resultado, pois veja, temos 2
estados possíveis para a porta: 1 e 0. O problema é que não sabemos o valor dos outros
bits. Pode ser que forme qualquer outra palavra fora 1 e 0. Mas isso é outra história. Nos
meus testes eu recebi 31 em decimal para 0 e 95 também em decimal para 1.
Na verdade se você parou para fazer os cálculos, percebeu que não bate, mas é confuso
assim mesmo. O problema é que além do byte do registrator status ser invertido, os bits
S6 e S7 também são invertidos, mais ou menos assim:
Tabela de mapeamento do registrador de status.
Pino
Nome
10
Ack
11
Busy
Sigla
Ordem
S6
1
S7
0
12
Paperout
S5
2
13
Select
X
15
Error
X
X
S4
3
S2
5
S3
4
S1
6
S0
7
É uma bagunça esse registrador!
O fato é que o bit que nos interessa é o Ack, que na ordem certa é o terceiro bit do
segundo nibble, ou seja, o penúltimo e não o segundo como era de se esperar. Temos
então 40 em hexadecimal e não 20. Basta fazer um “AND” lógico com esse valor para
saber se o bit é 40 ou 0. Deslocando o byte 6 posições para a direita, temos 1 e 0.
Nem sei fazer isso no VB, mas a receita é essa.
Lógica do Programa
Tabela de instruções de funcionamento do programa.
Um programa simples, apenas para testar a comunicação. Tem apenas um botão para
iniciar a comunicação e uma caixa de texto para apresentar o resultado.
Primeiro devemos enviar zero para a porta, a fim de zerar todos os bits. O endereço 888
é o da porta paralela LPT1. O comando Out é um apelido para uma API. No código do
módulo tem a declaração desse comando. O funcionamento é simples, basta pasar a
porta no primeiro parâmetro e o valor no segundo.
A função de atraso (delay) foi uma gambiarra que fiz para simular um clock de mais ou
menos 1 ms. Um loop que executa 5 mil vezes o comando DoEvents.
Depois de zerar a porta e esperar um tempo (delay) vamos colocar o Enable em alto
para indicar ao MC que vamos enviar um comando. Coloquei alguns delays na
sequencia pois o manual do micro pede esse tempo de preparo. O código em decimal
128 é igual a 80 em hexadecimal, portanto estamos ativando apenas o bit D7 do
registrador de dados. Reveja a tabela acima para lembrar.
Agora vamos enviar o primeiro bit. Ele é 1. Nesse caso vem o truque. Primeiro
levantamos o MOSI junto com o EN, pois este é o momento de transição que citei
antes. Então enviamos 160 em decimal que ativa os registradores D7 e D5.
Só então levantamos o sinal de sincronismo. Nesse caso passamos 176 para a porta no
intuito de colocar em alto os bits D7, D5 e D4, que esse último é o SCK.
Na sequencia executamos o delay para manter o sinal do clock em alto por um tempo.
Para completar o ciclo, passamos zero para o SCK e para o MOSI, mantendo o EN
sempre em alto.
Para finalizar, chamamos o delay para manter o clock em baixo por um tempo. Com
isso concluímos o ciclo de envio de um bit. Basta começar tudo de novo para enviar o
próximo. Veja na imagem que é possível ver o próximo bit sendo enviado. Repare que
como o próximo bit é zero, basta enviar 144 e manter o sinal do clock alto pelo tempo
determinado e está tudo certo. Não precisa reconfigurar o MOSI antes de levantar o
clock. Faltam 31 bits.
Fique atento após bit 24. A partir do bit 25, poderemos ler o retorno do MC enquanto o
clock estiver em alto. Para isso envie 144, chame o delay e logo antes de baixar o
clock, faça a leitura do bit, utilizando o comando Inp, também declarado como API no
módulo.
Para finalizar o código, devemos zerar a porta novamente. Isso fará com que o EN
fique em baixo e desabilite o modo de programação do MC. Com isso o micro
controlador entra em modo de operação normal e executa o programa gravado. No
nosso caso, não gravamos programa nenhum, apenas enviamos um comando.
Repare no retorno: 31, 95, 95, 31, 95, 31, 31, 95. Essa é a resposta para 0110 1001.
Conforme o manual do AT89S52 essa é a resposta certa para a ativação desse comando.
O Código Completo
Tabela da listagem do código-fonte.
Dim data As Integer
Form1.frm
Private Sub Command1_Click()
' Zerando porta
Out 888, 0
Call delay
' Ligando EN
Out 888, 128
Call delay
Call delay
Call delay
' Enviando Prog En
' Parte 1
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
' Parte 2
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
Out 888, 160
Out 888, 176
Call delay
Out 888, 128
Call delay
' Parte 3
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Out 888, 144
Call delay
Out 888, 128
Call delay
Text1.Text = ""
' Parte 4
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Out 888, 144
Call delay
Text1.Text =
Out 888, 128
Call delay
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ","
Text1.Text & Inp(889) & ""
' Zerando porta
Out 888, 0
Call delay
End Sub
Private Sub delay()
Dim i As Long
For i = 0 To 5000
DoEvents
Module1.bas
Next i
End Sub
Public Declare Function Inp Lib
"inpout32.dll" _
Alias "Inp32" (ByVal PortAddress As Integer)
As Integer
Public Declare Sub Out Lib "inpout32.dll" _
Alias "Out32" (ByVal PortAddress As Integer,
ByVal Value As Integer)
Conclusões
Bom, para concluir, vale a pena ficar de olho nos LEDs conectados nos pinos do cabo
de dados. Eles vão piscar conforme a partitura. É bem interessante. Fique de olho no
LED ao contrário, que é o ligado no MISO, pois quando ele piscar quer dizer que o MC
está respondendo ao comando!
Outra coisa curiosa é que a parte mais complicada de fazer um programa gravador de
E2PROM é a de carregar o arquivo INTEL HEX e decodificá-lo para enviar os bytes
certos para os endereços de memória certos. Isso dá trabalho.
A comunicação é a parte mais fácil.
Boa sorte e bons estudos!
Renato Aloi
12 de novembro de 2008