Tutorial Gravador 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: ISP-Flash 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 – 25V1 Capacitor de Cerâmica 100nF (104)2 Capacitores de Cerâmica 33pF (33)

1 Cristal de 12Mhz ou 11,0592Mhz

1 Diodo 1N40071 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.

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.

Não existe conexão entre os dois lados.

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.

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.

Pino 1Pino 1

MISO

GND

ENMOSI

SCK

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 DB25 (porta paralela) Conector ISP

MOSI 7 1EN 9 2

MISO 10 3SCK 6 4GND 25 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:

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 41 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 1Resposta 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

PC MCSentido da comunicação

0 ← 1 ← 2 ← 3 ← 4 ← 5 ← 6 ← 7

Sentido do envio dos bits

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.D7 D6 D5 D4 D3 D2 D1 D0 Hex. Dec.

EN 1 0 0 0 0 0 0 0 80 128EN+MOSI 1 0 1 0 0 0 0 0 A0 160EN+SCK 1 0 0 1 0 0 0 0 90 144EN+MOSI+SCK 1 0 1 1 0 0 0 0 B0 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 S1 S2 S3 S4 S5 S6 S7 Hex. Dec.X X X X X X 1 X 5F 95X X X X X X 0 X 1F 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 10 11 12 13 X 15 X XNome Ack Busy Paper-

outSelect Error

Sigla S6 S7 S5 S4 S2 S3 S1 S0Ordem 1 0 2 3 5 4 6 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.Form1.frm Dim data As Integer

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 = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "," Out 888, 128 Call delay Out 888, 144 Call delay Text1.Text = Text1.Text & Inp(889) & "" Out 888, 128 Call delay ' Zerando porta Out 888, 0 Call delayEnd Sub

Private Sub delay() Dim i As Long For i = 0 To 5000 DoEvents

Next iEnd Sub

Module1.bas Public Declare Function Inp Lib "inpout32.dll" _Alias "Inp32" (ByVal PortAddress As Integer) As IntegerPublic 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 Aloi12 de novembro de 2008