AVR Assembler Tutorial 9: 7 etapas

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

Bem-vindo ao Tutorial 9.

Hoje mostraremos como controlar um display de 7 segmentos e um display de 4 dígitos usando nosso código de linguagem assembly ATmega328P e AVR. Ao fazer isso, teremos que nos desviar de como usar a pilha para reduzir o número de registros que precisamos amarrar. Adicionaremos alguns capacitores (filtros passa-baixa) para tentar reduzir o ruído em nosso teclado. Criaremos um amplificador de tensão com alguns transistores para que nossa chave de interrupção INT0 funcione melhor para os botões de tensão mais baixa na linha inferior do teclado. E bateremos nossas cabeças contra a parede um pouco tentando conseguir os resistores corretos para que a coisa funcione corretamente.

Estaremos usando nosso teclado do Tutorial 7

Para fazer este tutorial, além do material padrão, você precisará de:

1. Um display de 7 segmentos

   www.sparkfun.com/products/8546

2. Um display de 4 dígitos

   www.sparkfun.com/products/11407

3. Um botão de pressão

   www.sparkfun.com/products/97

4. As folhas de dados do display, que podem ser baixadas de suas respectivas páginas com link acima.
5. Um capacitor de cerâmica de 68 pf, um par de 104 capacitores, um monte de resistores, dois transistores NPN 2N3904.

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

Etapa 1: conectando o monitor 7-seg

Usaremos o mesmo código que usamos no Tutorial 7 para o teclado para controlar o display de 7 segmentos. Portanto, você precisará fazer uma cópia disso e iremos modificá-lo.

Mapearemos os segmentos para os pinos do nosso microcontrolador da seguinte maneira:

(dp, g, f, e, d, c, b, a) = (PD7, PD6, PB5, PB4, PB3, PB2, PB1, PB0)

onde as letras dos segmentos são mostradas na imagem junto com a pinagem correspondente a 5V comum e cada um dos segmentos de LED incluindo o ponto decimal (dp) no canto inferior direito do display. A razão para isso é que podemos inserir o número inteiro em um único registro e enviar esse registro para as portas B e D para iluminar os segmentos. Como você pode ver, os bits são numerados sequencialmente de 0 a 7 e, portanto, serão mapeados para os pinos corretos sem a necessidade de definir e limpar bits individuais.

Como você pode ver pelo código que anexamos na próxima etapa, movemos nossa rotina de exibição para uma macro e liberamos os pinos SDA e SCL para uso futuro no próximo Tutorial.

Devo acrescentar que você precisa colocar um resistor entre o ânodo comum da tela e o trilho de 5V. Escolhi um resistor de 330 ohms como de costume, mas se você quiser, pode calcular a resistência mínima necessária para obter o brilho máximo da tela sem fritá-la. Aqui está como fazer isso:

Primeiro, olhe para a folha de dados e observe que na primeira página ela fornece várias propriedades do display. As grandezas importantes são a "Corrente direta" (I_f = 20mA) e a "Tensão direta" (V_f = 2,2 V). Eles indicam que você deseja que a queda de tensão na tela seja se a corrente for igual à corrente direta. Esta é a corrente máxima que o monitor irá receber sem fritar. Consequentemente, é também o brilho máximo que você pode obter dos segmentos.

Então, vamos usar a lei de Ohm e a regra de loop de Kirchoff para descobrir qual resistência mínima precisaríamos colocar em série com a tela para obter o brilho máximo. A regra de Kirchoff diz que a soma das mudanças de voltagem em torno de um circuito fechado em um circuito é igual a zero e a lei de Ohm diz que a queda de voltagem em um resistor de resistência R é: V = I R onde I é a corrente fluindo através do resistor.

Assim, dada uma fonte de tensão de V e percorrendo nosso circuito, temos:

V - V_f - I R = 0

o que significa (V - V_f) / I = R. Portanto, a resistência necessária para obter o brilho máximo (e provavelmente fritar os segmentos) seria:

R = (V - V_f) / I_f = (5,0V - 2,2V) / 0,02A = 140 ohms

Portanto, se você quiser, poderá usar 150 ohms sem preocupações. No entanto, acho que 140 ohms o tornam muito brilhante para o meu gosto, então eu uso 330 ohms (que é uma espécie de resistência pessoal Cachinhos Dourados para LEDs)

Etapa 2: Código de montagem e vídeo

Anexei o código de montagem e um vídeo mostrando o funcionamento do teclado com o display. Como você pode ver, simplesmente mapeamos a tecla Redial para "r", a tecla flash para "F", o asterisco para "A" e o sinal de hash para "H". Eles podem ser mapeados para várias operações, como backspace, enter e outras coisas, se você quiser continuar a usar o teclado para digitar números em monitores LCD ou monitores de 4 dígitos. Não vou percorrer o código linha por linha desta vez, pois é muito semelhante ao que já fizemos nos tutoriais anteriores. As diferenças são principalmente mais das mesmas coisas que já sabemos fazer, como interrupções e tabelas de consulta. Você deve apenas percorrer o código e olhar para as coisas novas que adicionamos e as coisas que mudamos e descobrir a partir daí. Voltaremos à análise linha por linha no próximo tutorial, quando apresentarmos novos aspectos da codificação em linguagem assembly em microcontroladores AVR.

Vejamos agora um display de 4 dígitos.

Etapa 3: conectando o display de 4 dígitos

De acordo com a ficha técnica, o display de 4 dígitos tem uma corrente direta de 60 mA e uma tensão direta de 2,2 volts. Então, pelo mesmo cálculo de antes, eu poderia usar um resistor de 47 ohms se eu quisesse. Em vez disso, vou usar um … hrm … deixe-me ver … que tal 330 ohms.

O modo como o display de 4 dígitos é conectado é que existem 4 ânodos, um para cada um dos dígitos, e os outros pinos controlam qual segmento é ativado em cada um. Você pode exibir 4 dígitos simultaneamente porque eles são multiplexados. Em outras palavras, assim como fizemos com o par de dados, simplesmente alternamos a alimentação por meio de cada um dos ânodos e ele os piscará um após o outro. Ele fará isso tão rápido que nossos olhos não verão o piscar e parecerá que todos os quatro dígitos estão ativados. No entanto, apenas para ter certeza, a maneira como o codificaremos é definir todos os quatro dígitos e, em seguida, alternar os ânodos, em vez de definir, mover, definir, mover, etc. Dessa forma, podemos obter um tempo preciso entre acender cada dígito.

Por enquanto, vamos testar se todos os segmentos funcionam.

Coloque o resistor de 330 ohms entre o trilho positivo da placa de ensaio e o primeiro ânodo da tela. A folha de dados nos diz que os pinos são numerados de 1 a 16 no sentido anti-horário começando na parte inferior esquerda (quando você está olhando para a tela normalmente.. com os pontos decimais na parte inferior) e afirma que os ânodos são os números dos pinos 6, 8, 9 e 12.

Assim, conectamos o pino 6 a 5V e, em seguida, pegamos um fio negativo do trilho GND e o colocamos em todos os outros pinos e vemos que todos os segmentos acendem no dígito a que corresponde (que é na verdade o segundo dígito de o certo). Certifique-se de acender todos os 7 segmentos e o ponto decimal.

Agora coloque seu fio GND em um dos pinos para iluminar um dos segmentos e desta vez mova o resistor ao redor dos outros 3 ânodos e veja que o mesmo segmento acende em cada um dos outros dígitos.

Algo incomum?

Acontece que a pinagem na folha de dados está errada. Isso ocorre porque é a folha de dados e a pinagem de um display de 12 pinos e 4 dígitos. Ou seja, um sem dois pontos ou ponto decimal superior. O visor que recebi quando fiz o pedido é um visor de 4 dígitos e 16 pinos. Na verdade, no meu, os ânodos de segmento estão nos pinos 1, 2, 6 e 8. O ânodo do cólon é o pino 4 (pino do cátodo 12) e o ânodo dp superior é o pino 10 (o cátodo é o pino 9)

Exercício 1: Use seu resistor e fio terra para mapear qual pino corresponde a qual segmento e ponto decimal no visor para obtermos os segmentos corretos acendendo quando o codificarmos.

A maneira como queremos codificar o mapa de segmento é exatamente como fizemos com o display de 7 segmentos de um único dígito acima - não temos que mudar nada no código, a única coisa que mudamos é como os fios são conectados no quadro. Simplesmente conecte o pino da porta correta no microcontrolador ao pino correspondente no display de 4 dígitos para que, por exemplo, PB0 ainda vá para o pino correspondente ao segmento a, PB1 vá para o segmento B, etc.

A única diferença é que agora precisamos de 4 pinos extras para os ânodos, já que não podemos mais simplesmente ir para o trilho de 5V. Precisamos do microcontrolador para decidir qual dígito obtém o suco.

Portanto, usaremos PC1, PC2, PC3 e PD4 para controlar os ânodos dos 4 dígitos.

Você também pode ir em frente e conectar os fios. (não se esqueça dos resistores de 330 ohms nos fios do ânodo!)

Etapa 4: codificando a tela de 4 dígitos

Vamos pensar sobre como queremos codificar esta exibição.

Gostaríamos que o usuário pressionasse os botões do teclado e fizesse os números aparecerem sequencialmente no visor à medida que pressionava cada botão. Portanto, se eu pressionar 1 seguido de 2, ele aparecerá no visor como 12. Também gostaria de armazenar esse valor, 12, para uso interno, mas falaremos disso um pouco mais tarde. Por enquanto, eu só quero escrever uma nova macro que pegue suas teclas e as exiba. No entanto, como temos apenas 4 dígitos, quero ter certeza de que ele só permite que você digite quatro números.

Outro problema é que a maneira como o display multiplexado de 4 dígitos funciona é alternando os ânodos de modo que cada dígito fique ligado apenas por uma fração de segundo antes de exibir o próximo e depois o próximo e, finalmente, de volta ao primeiro novamente, etc. Então, nós precisa de uma maneira de codificar isso.

Também queremos que ele mova o "cursor" para um espaço à direita ao digitar o próximo dígito. Assim, se eu quiser digitar 1234, por exemplo, depois de digitar 1, o cursor se moverá para que o próximo dígito que eu digitar apareça no próximo display de 7 segmentos e assim por diante. Enquanto isso está acontecendo, eu ainda quero ser capaz de ver o que digitei, então ainda tenho que percorrer os dígitos e exibi-los.

Soa como uma tarefa difícil?

As coisas estão ainda piores. Precisamos de mais 4 registradores de propósito geral que possamos usar para armazenar os valores atuais dos 4 dígitos que queremos exibir (se vamos percorrê-los, temos que mantê-los armazenados em algum lugar) e o problema com isso é que temos Temos usado registradores de uso geral como um louco e se não tomarmos cuidado não teremos mais nenhum. Portanto, é provavelmente uma boa ideia resolver esse problema o quanto antes e mostrar a você como liberar registradores usando a pilha.

Portanto, vamos começar simplificando um pouco as coisas, usar a pilha e liberar alguns registros e então tentaremos realizar a tarefa de ler e exibir nossos números no display de 4 dígitos.

Etapa 5: Push 'n Pop

Existem apenas alguns "registros de uso geral" que temos à nossa disposição e, uma vez usados, não existem mais. Portanto, é uma boa prática de programação usá-los apenas para algumas variáveis que são usadas como armazenamento temporário que você precisa para ler e gravar portas e SRAM com, ou então aquelas que você precisará em sub-rotinas em todos os lugares e assim você nomeie-os. Então, o que eu fiz, agora que inicializamos e estamos aprendendo a usar o Stack, é percorrer o código e encontrar os registradores de propósito geral nomeados que são usados apenas dentro de uma única sub-rotina ou interrupção e em nenhum outro lugar do código e substituir com um de nossos registros temporários e um push e pop para a pilha. Na verdade, se você olhar para o código escrito para microcontroladores menores, ou se você voltar no tempo para quando todos os chips eram menores, você verá apenas alguns registros de uso geral que tiveram que ser usados para tudo, então você não poderia apenas armazene um valor lá e deixe-o como está, já que você tinha certeza de que precisaria daquele registro para outras coisas. Então, você verá pushin 'e um poppin' em todo o lugar no código. Talvez eu devesse ter nomeado nossos registradores temporários de uso geral AX e BX como um elogio respeitoso àqueles dias que se foram.

Um exemplo ajudará a tornar isso mais claro.

Observe que em nossa interrupção completa de conversão de analógico para digital ADC_int, usamos um registro de propósito geral que chamamos de buttonH, que usamos para carregar o valor de ADCH e compará-lo com nossa tabela de pesquisa de conversões de analógico para pressionamento de botão. Só usamos este registrador buttonH dentro da sub-rotina ADC_int e em nenhum outro lugar. Então, em vez disso usaremos nossa variável temp2 que usamos como uma variável temporária que podemos usar em qualquer sub-rotina dada e seu valor não afetará nada fora dessa sub-rotina (ou seja, o valor que damos a ele em ADC_int não será usado em qualquer lugar outro).

Outro exemplo está em nossa macro de atraso. Temos um registro que chamamos de "milissegundos" que contém nosso tempo de atraso em milissegundos. Neste caso, está em uma macro e lembramos que a maneira como a macro funciona é que o montador coloca todo o código da macro no local do programa onde é chamado. Neste caso, gostaríamos de nos livrar da variável "milissegundos" e substituí-la por uma de nossas variáveis temporárias. Nesse caso, vou fazer isso de maneira um pouco diferente para mostrar como, mesmo que o valor da variável seja necessário em outro lugar, ainda podemos usá-lo usando a pilha. Então, em vez de milissegundos, usamos "temp" e para não bagunçarmos outras coisas que também usam o valor de temp, simplesmente começamos a macro "delay" empurrando "temp" para a pilha e depois a usamos em vez de milissegundos e, no final da macro, "retiramos" seu valor anterior da pilha.

O resultado líquido é que "pegamos emprestado" temp e temp2 para uso temporário e, em seguida, restauramos seus valores anteriores quando terminarmos.

Aqui está a rotina de interrupção ADC_int após fazer esta alteração:

ADC_int:

push temp; salvar a temperatura, pois nós a modificamos aqui, pressione temp2; salvar temp2 lds temp2, ADCH; carregar tecla pressionada ldi ZH, alto (2 * números) ldi ZL, baixo (2 * números) cpi temp2, 0 breq retornar; se os disparadores de ruído não mudarem 7segundo setkey: lpm temp, Z +; carregar da tabela e pós-incremento clc cp temp2, temp; compare keypress com a tabela brlo PC + 4; se ADCH for menor, tente novamente lpm 7segnumber, Z; caso contrário, carregue a tabela de valores-chave inc dígito; incrementa o número do dígito rjmp return; e retorno adiw ZH: ZL, 1; incremento Z rjmp setkey; e voltar ao topo retornar: pop temp2; restaurar temp2 pop temp; restaurar a temperatura reti

Observe que a maneira como a pilha funciona é que o primeiro a ser ativado é o último a ser desativado. Como uma pilha de papéis. Você vê que em nossas duas primeiras linhas colocamos o valor de temp na pilha, depois colocamos temp2 na pilha, depois os usamos na sub-rotina para outras coisas e, finalmente, os restauramos aos valores anteriores novamente por primeiro removendo temp2 (uma vez que foi o último empurrado, está no topo da pilha e será o primeiro que removemos) e, em seguida, removendo temp.

Portanto, de agora em diante, sempre usaremos esse método. A única vez em que realmente designaremos um registrador para algo diferente de uma variável temporária é quando precisaremos dele em todos os lugares. Por exemplo, o registro chamado "overflows" é aquele que usamos em vários lugares diferentes no programa e, portanto, gostaríamos de lhe dar um nome. É claro que ainda poderíamos usá-lo da maneira que fizemos com temp e temp2, já que restauraríamos seu valor depois de terminarmos. Mas isso complicaria demais as coisas. Eles foram nomeados por um motivo e temos temp e temp2 já designados para esse trabalho.

Etapa 6: Filtros passa-baixa e amplificador de tensão

Para limpar um pouco o ruído e fazer nosso teclado funcionar melhor, queremos adicionar alguns filtros passa-baixa. Eles filtram o ruído de alta frequência e permitem a passagem do sinal de baixa frequência. Essencialmente, a maneira de fazer isso é simplesmente adicionar um capacitor de 68 pf entre nossa entrada analógica e o terra e também um capacitor de 0,1 microfarad (ou seja, 104) entre nossa interrupção PD4 (INT0) e o terra. Se você brincar com eles enquanto pressiona os botões do teclado, poderá ver o que eles fazem.

Em seguida, queremos fazer um amplificador de voltagem. Acontece que a linha inferior de teclas do teclado (bem como a tecla de rediscagem) estão emitindo uma tensão muito baixa para desarmar a interrupção INT0. A porta analógica é sensível o suficiente para ler as tensões baixas dessas teclas, mas nosso pino de interrupção não está obtendo uma borda de subida boa o suficiente para interromper quando pressionamos essas teclas. Portanto, gostaríamos de ter certeza de que uma boa borda ascendente de tensão atinge PD4, mas a mesma baixa tensão atinge ADC0. Esta é uma tarefa muito difícil, pois ambos os sinais vêm do mesmo fio de saída do nosso teclado. Existem várias maneiras sofisticadas de fazer isso, mas não usaremos mais nosso teclado após este tutorial, então vamos juntar um método que funcione (mal).

Você deve primeiro conectar um botão externo para substituir a interrupção INT0 e controlar a tela segurando uma tecla no teclado e clicando no botão. Isso tem menos problemas de teclado e permitirá que você tenha certeza de que suas tensões estão definidas corretamente na tabela de consulta do teclado. Depois de saber que o teclado está conectado corretamente, livre-se do botão e coloque a interrupção INT0 de volta. Existem alguns problemas sérios de ruído e tensão controlando o teclado dessa forma, então é bom saber que tudo funciona para que problemas futuros possam ser isolados da tecla INT0.

Quando você conecta seu teclado e seu amplificador de tensão, é muito provável que os mesmos valores de resistor que usei não funcionem. Portanto, você terá que fazer algumas experiências para obter valores que funcionem para você.

Se você olhar o diagrama que anexei a esta etapa, verá como o amplificador de voltagem vai funcionar. Usamos alguns resistores e dois transistores. A forma como os transistores funcionam (veja as folhas de dados!) É que existe uma tensão mínima que você precisa inserir no pino da base do transistor (o pino do meio), que irá saturá-lo e permitir que a corrente flua entre o pino do coletor e o emissor alfinete. No caso do transistor 2N3904 que estamos usando aqui a tensão é de 0,65V. Agora estamos pegando essa tensão de nossa saída do teclado e não queremos mudar essa saída, então colocaremos um resistor grande entre a saída do teclado e a base do primeiro transistor (usei 1Mohm). Eu rotulei isso como R_1 no diagrama. Em seguida, queremos configurar um divisor de tensão de forma que a base do transistor já esteja "quase" com 0,65 volts e apenas um pouquinho mais o empurre para cima e o sature. Essa pequena parte virá da saída do teclado quando pressionamos um botão. Como as teclas inferiores do teclado estão emitindo apenas uma pequena voltagem, precisamos estar bem próximos da saturação para que sejam suficientes. Os resistores do divisor de tensão são identificados como R_a e R_b no diagrama. Usei R_a = 1Mohm e R_b = 560Kohm, mas é quase certo que você terá que brincar com esses números para acertar em sua configuração. Você pode querer ter uma parede próxima para bater sua cabeça e dois ou três copos de uísque à mão (eu recomendaria Laphroaig - caro, mas vale a pena se você gosta de fumar. Se as coisas ficarem realmente loucas, então é só pegar uma jarra de BV e prepare-se para passar a noite)

Agora vamos ver como os transistores vão nos dar uma bela borda ascendente indo para a tecla INT0 e gerar nossa interrupção de pressionamento de tecla. Primeiro, vamos ver o que acontece quando não estou pressionando uma tecla. Nesse caso, o primeiro transistor (identificado como T1 no diagrama) está desligado. Portanto, nenhuma corrente está fluindo entre os pinos do coletor e do emissor. Assim, a base do outro transistor (identificado como T2) será puxada para cima e, portanto, saturará, permitindo que a corrente flua entre seus pinos. Isso significa que o emissor de T2 será puxado para baixo, pois está conectado ao coletor, que por sua vez está conectado ao aterramento. Portanto, a saída que vai para nosso pino de interrupção de pressionamento de tecla INT0 (PD4) será baixa e não haverá interrupção.

Agora, o que acontece quando eu pressiono uma tecla? Bem, então a base de T1 vai acima de 0,65V (no caso das chaves inferiores ela vai apenas um pouco acima!) E então a corrente será permitida fluir o que puxará a base de T2 para baixa tensão e isso desligará T2. Mas vemos que quando T2 está desligado, a saída é elevada e, portanto, obteremos um sinal de 5 V indo para nosso pino INT0 e isso causará uma interrupção.

Observe qual é o resultado líquido aqui. Se pressionarmos a tecla 1, obteremos 5 V indo para PD4 sem alterar significativamente a saída indo para ADC0 e, mais importante, mesmo se pressionarmos Asterisk, 0, Hash ou Redial, também obteremos um sinal de 5 V indo para INT0 e também causando uma interrupção! Isso é importante, pois se apenas passarmos diretamente da saída do teclado para o pino INT0, essas teclas quase não geram tensão e não serão suficientes para acionar esse pino de interrupção. Nosso amplificador de tensão resolveu esse problema.

Etapa 7: código de exibição de 4 dígitos e vídeo

Isso é tudo para o tutorial 9! Anexei o código e um vídeo mostrando a operação.

Esta será a última vez que usaremos o teclado analógico (graças a Deus). Era difícil de usar, mas também muito útil para nos ajudar a aprender sobre a conversão analógico-digital, portas analógicas, interrupções, multiplexação, filtros de ruído, amplificadores de voltagem e muitos aspectos da codificação de montagem de tabelas de pesquisa a temporizadores / contadores, etc. É por isso que decidimos usá-lo. (além disso, é divertido limpar coisas).

Agora vamos examinar a comunicação novamente e obter nossos displays de 7 segmentos e 4 dígitos para ler nossos rolos de dados de nosso rolo de dados da mesma forma que fizemos com nosso analisador de registro. Desta vez, usaremos a interface de dois fios em vez de nosso método de código morse hackeado.

Assim que tivermos as comunicações funcionando e os rolos aparecendo nos monitores, podemos finalmente fazer a primeira peça de nosso produto final. Você notará que, sem todas as coisas da porta analógica, nosso código será significativamente mais curto e provavelmente mais fácil de ler.

Para aqueles de vocês que são ambiciosos. Aqui está um "projeto" que você pode tentar, mas certamente tem o conhecimento para fazer neste ponto, se tiver passado por todos esses tutoriais até este ponto:

Projeto: Faça uma calculadora! Use nosso display de 4 dígitos e nosso teclado e adicione um botão externo que funcionará como uma tecla "enter". Mapeie o asterisco para "vezes", o hash para "dividir" a rediscagem para "mais" e o flash para "menos" e escreva uma rotina de calculadora que funcione como uma daquelas antigas calculadoras de "polimento reverso" da HP que todos os engenheiros tinham antigamente. Ou seja, a forma como funcionam é que você insere um número e pressiona "enter". Isso empurra aquele número para a pilha, então você insere um segundo número e pressiona "enter", o que empurra o segundo número para a pilha. Finalmente, você pressiona uma das operações como X, /, + ou - e ela aplicará essa operação aos dois primeiros números da pilha, exibirá o resultado e colocará o resultado na pilha para que você possa usá-lo novamente se você gostar. Por exemplo, para adicionar 2 + 3, você faria: 2, "digite", 3, "digite", "+" e o display mostraria 5. Você sabe como usar a pilha, o display, o teclado e você ter a maior parte do código de fundo já escrito. Basta adicionar a tecla Enter e as sub-rotinas necessárias para a calculadora. É um pouco mais complicado do que você pode pensar à primeira vista, mas é divertido e prático.

Vejo você na próxima vez!