AVR Assembler Tutorial 6: 3 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:34

Bem-vindo ao Tutorial 6!

O tutorial de hoje será curto, onde desenvolveremos um método simples para comunicar dados entre um atmega328p e outro usando duas portas conectando-os. Em seguida, pegaremos o rolo de dados do Tutorial 4 e o Analisador de Registro do Tutorial 5, conectá-los e usaremos nosso método para comunicar o resultado dos rolos de dados do rolo para o analisador. Em seguida, imprimiremos o rolo em binário usando os LEDs que construímos para o analisador no Tutorial 5. Assim que tivermos isso funcionando, seremos capazes de construir a próxima parte de nosso projeto geral no próximo tutorial.

Neste tutorial, você precisará:

1. Sua placa de prototipagem
2. Seu rolo de dados do Tutorial 4
3. Seu Register Analyzer do Tutorial 5
4. Dois fios de conexão

5. Uma cópia da Folha de Dados Completa (revisão de 2014):

   www.atmel.com/images/Atmel-8271-8-bit-AVR-M…

6. Uma cópia do Manual do Conjunto de Instruções (revisão de 2014):

   www.atmel.com/images/atmel-0856-avr-instruc…

Aqui está um link para a coleção completa de meus tutoriais de assembler AVR:

Etapa 1: Como podemos fazer com que dois microcontroladores se comuniquem?

Como estamos começando a expandir nosso projeto para que nosso produto final único seja composto de uma coleção de peças menores, vamos precisar de mais pinos do que um único Atmega328P pode fornecer. Portanto, faremos cada parte do projeto geral em um microcontrolador separado e, em seguida, faremos com que eles compartilhem os dados entre eles. Portanto, o problema que precisamos resolver é como podemos chegar a um método simples para os controladores se comunicarem e transferirem dados entre eles? Bem, uma coisa sobre esses controladores é que cada um executa 16 milhões de instruções por segundo. Isso é cronometrado com muita precisão e, portanto, podemos usá-lo para transferir dados. Se usarmos atrasos de milissegundos para constituir os dados, não precisamos ser tão precisos, pois a CPU está executando 16.000 instruções em um único milissegundo. Em outras palavras, um milissegundo é uma eternidade para a CPU. Então, vamos tentar com as jogadas de dados. Desejo transmitir o resultado de um lançamento de dados da ficha do rolo de dados para a ficha do analisador. Suponha que você esteja do outro lado da rua e eu queira sinalizar para você o resultado de meu lançamento de um par de dados. Uma coisa que eu poderia fazer, se nós dois tivéssemos um relógio, é ligar uma lanterna, então quando você estiver pronto para receber meus dados, você liga sua lanterna e nós dois ligamos nossos relógios. Então eu mantenho minha lanterna ligada pelo número exato de milissegundos enquanto os dados rolam e depois a desligo. Então, se eu rolasse um 12, manteria minha luz acesa por 12 milissegundos. Agora, o problema com o acima é que, para você e eu, não haveria como cronometrar as coisas com precisão suficiente para distinguir entre 5 milissegundos e 12 milissegundos. Mas e quanto a isto: suponha que decidimos que manteria minha luz acesa por um ano para cada número nos dados? Então, se eu rolar um 12, eu iluminaria você por 12 anos e acho que você concordará que não há possibilidade de cometer um erro ao descobrir o número certo? Você poderia fazer uma pausa e ir jogar beisebol, você poderia até jogar dados em Vegas por 6 meses, desde que em algum momento durante o ano para olhar para o outro lado da rua para ver se a luz estava acesa você não perderia uma contagem. Bem, isso é exatamente o que estamos fazendo para os microcontroladores! Um único milissegundo para a CPU é como um ano. Portanto, se eu ligar o sinal por 12 milissegundos, quase não haverá chance de que o outro microcontrolador o confunda para 10 ou 11, não importa quais interrupções ou coisas não aconteçam nesse ínterim. Para os microcontroladores, um milissegundo é uma eternidade. Então, aqui está o que faremos. Primeiro, escolheremos duas portas no controlador para serem nossas portas de comunicação. Vou usar PD6 para receber dados (podemos chamá-lo de Rx se quisermos) e vou escolher PD7 para transmitir dados (podemos chamá-lo de Tx se quisermos). O chip analisador verificará periodicamente seu pino Rx e se vir um sinal, ele cairá para uma "sub-rotina de comunicação" e, em seguida, transmitirá um sinal de retorno para o rolador de dados dizendo que está pronto para receber. Ambos começarão a cronometrar e o rolo de dados transmitirá um sinal (ou seja, 5 V) por um milissegundo por número no dado. Portanto, se o lançamento fosse duplo seis ou 12, o rolo de dados configuraria PD7 em 5V por 12 milissegundos e, em seguida, configuraria novamente para 0V. O analisador verificará seu pino PD6 a cada milissegundo, contando todas as vezes, e quando ele voltar a 0 V, ele enviará o número resultante para o visor do analisador, mostrando um doze em binário nos LEDs. Então esse é o plano. Vamos ver se podemos implementá-lo.

Etapa 2: sub-rotinas de comunicação

A primeira coisa que precisamos fazer é conectar os dois controladores. Portanto, pegue um fio do PD6 em um e conecte-o ao PD7 no outro e vice-versa. Em seguida, inicialize-os configurando PD7 para OUTPUT em ambos e PD6 para INPUT em ambos. Finalmente, defina todos eles para 0V. Especificamente, adicione o seguinte à seção Init ou Reset do código em cada microcontrolador:

sbi DDRD, 7; PD7 definido para saída

cbi PortD, 7; PD7 inicialmente 0 V cbi DDRD, 6; PD6 definido para entrada cbi PortD, 6; PD6 inicialmente 0V clr total; total nos dados inicialmente 0

Agora vamos configurar a sub-rotina de comunicações no chip do rolo de dados. Primeiro defina uma nova variável no topo chamada "total" que armazenará o número total lançado no par de dados e o inicializará para zero.

Em seguida, escreva uma sub-rotina para se comunicar com o analisador:

comunicar:

cbi PortD, 7 sbi PortD, 7; Enviar sinal de pronto, aguardar: sbic PinD, 6; ler PinD e pular se 0V rjmp wait delay 8; atraso para sincronizar (encontrado experimentalmente) send: dec total delay 2; atraso para cada contagem de dados cpi total, 0; 0 aqui significa atrasos de número "total" enviados breq PC + 2 rjmp send cbi PortD, 7; PD7 a 0V clr total; redefinir o total de dados para 0 ret

No analisador, adicionamos uma rcall da rotina principal à sub-rotina de comunicação:

analisador de clr; prepare-se para o novo número

sbic PinD, 6; verifique o PD6 para um sinal de comunicação de rcall de 5 V; se 5V vão para comunicar analisador mov, total; saída para o analisador, exibir o analisador rcall

e, em seguida, escreva a sub-rotina de comunicação da seguinte forma:

comunicar:

clr total; redefinir o total para 0, atraso 10; demora para se livrar de saltos sbi PortD, 7; definir PB7 para 5V para sinalizar recepção pronta: atraso 2; aguarde o próximo número inc total; incremento sbic PinD total, 6; se o PD6 voltar a 0V, terminamos o recebimento do rjmp; caso contrário, faça um loop de volta para mais dados cbi PortD, 7; reiniciar PD7 quando terminar ret

Ai está! Agora, cada microcontrolador está configurado para comunicar o resultado do lançamento de dados e, em seguida, exibi-lo no analisador.

Implementaremos uma forma muito mais eficiente de comunicação mais tarde, quando precisarmos transferir o conteúdo de um registrador entre controladores em vez de apenas um lançamento de dados. Nesse caso, ainda usaremos apenas dois fios conectando-os, mas usaremos 1, 1 para significar "iniciar a transmissão"; 0, 1 significa "1"; 1, 0 significa "0"; e finalmente 0, 0 para significar "transmissão final".

Exercício 1: Veja se você pode implementar o melhor método e usá-lo para transferir o lançamento de dados como um número binário de 8 bits.

Vou anexar um vídeo que mostra o meu em funcionamento.

Etapa 3: Conclusão

Anexei o código completo para sua referência. Não está tão limpo e arrumado como eu gostaria, mas vou limpá-lo à medida que o expandirmos em tutoriais futuros.

De agora em diante, apenas anexarei os arquivos que contêm o código, em vez de digitar tudo aqui. Vamos apenas digitar as seções que estamos interessados em discutir.

Este foi um pequeno tutorial em que criamos um método simples de dizer ao nosso microcontrolador analisador qual é o resultado de nosso lançamento de dados de nosso microcontrolador de rolo de dados usando apenas duas portas.

Exercício 2: Em vez de usar um sinal de pronto para mostrar quando o rolo de dados está pronto para transmitir e outro quando o analisador está pronto para receber, use uma "interrupção externa" chamada "Interrupção de troca de pino". Os pinos no atmega328p podem ser usados dessa forma, por isso eles têm PCINT0 a PCINT23 ao lado deles no diagrama de pinagem. Você pode implementar isso como uma interrupção de maneira semelhante à que fizemos com a interrupção de estouro do temporizador. Nesse caso, o "manipulador" de interrupção será a sub-rotina que se comunica com o lançador de dados. Dessa forma, você não precisa realmente chamar a sub-rotina de comunicações do principal: ela irá para lá sempre que houver uma interrupção proveniente de uma mudança de estado naquele pino.

Exercício 3: Uma maneira muito melhor de comunicar e transferir dados entre um microcontrolador para uma coleção de outros é usar a interface serial de 2 fios embutida no próprio microcontrolador. Tente ler a seção 22 da folha de dados e veja se você consegue descobrir como implementá-la.

Usaremos essas técnicas mais sofisticadas no futuro, quando adicionarmos mais controladores.

O fato de que tudo o que fizemos com nosso analisador foi pegar o total do lançamento de dados e depois imprimi-lo em binário usando LEDs não é o que importa. O fato é que agora nosso analisador "sabe" o que é o lançamento de dados e pode usá-lo de acordo.

No próximo tutorial estaremos mudando o propósito do nosso "analisador", introduzindo mais alguns elementos de circuito, e usando o lançamento de dados de uma forma mais interessante.

Até a próxima vez…