Interruptores de leitura com ATtiny2313: 9 etapas

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

Existem vários Instructables que lidam com saídas do ATtiny2313 e dispositivos AVR semelhantes. Por exemplo, https://www.instructables.com/id/Ghetto-Programming%3a-Getting-started-with-AVR-micro/, https://www.instructables.com/id/Drive-a-Stepper- Motor com um microprocessador AVR /. Trabalhando no último do The Real Elliot, que mostrou como controlar motores de passo, descobri que seria realmente útil ser capaz de executar seções de código alternativas no mesmo programa para não ter que reprogramar o ATtiny2313 cada vez que eu queria tentar uma pequena variação de código (como meio-passo ou executar o stepper ao contrário). Embora seja fácil escrever código usando uma instrução switch / case para permitir a seleção de variações alternativas, é necessária alguma maneira de selecionar o caso. Isso significa que algum tipo de dispositivo de entrada deve ser lido para controlar o caso. Felizmente, o ATtiny2313 tem muitos pinos de E / S e é bem projetado para ler entradas de interruptores. Este Instructable mostrará como ler entradas e tomar decisões com base em seu estado. Já que isso por si só já tornaria um Instructable muito chato, explicarei uma maneira simples de usar a capacidade de cronômetro / contador do ATtiny2313 para acionar um pequeno alto-falante como um bip. Haverá também uma pequena digressão sobre técnicas simples de depuração.

Etapa 1: o dispositivo de entrada

Este Instructable baseia-se no excelente trabalho de The Real Elliot e usa o sistema de desenvolvimento ATtiny2313 Ghetto que ele descreve. A folha de dados ATtiny2313 da Atmel é a referência definitiva para todas as funções, mas não é necessariamente fácil de ler. https://www.atmel.com/dyn/products/datasheets.asp?family_id=607 (Link tem todas as planilhas de dados AVR, localize o 2313.) A figura mostra um conjunto simples de interruptores de entrada. Este é simplesmente um pacote de quatro interruptores liga / desliga; também conhecido como single pole, single throw switches (SPST). Normalmente, uma conexão, ou pólo, de cada chave é ligada ao aterramento enquanto a outra conexão é puxada para cima por meio de um resistor limitador de corrente (10K ou mais). Uma entrada do microcontrolador é conectada ao pólo com o resistor. Se a chave estiver aberta, o microcontrolador lerá a entrada como HI. Se a chave estiver fechada, o microcontrolador lerá a entrada LO. Consulte o esquema para obter detalhes. O ATtiny2313 simplifica as coisas, fornecendo resistores pull-up programáveis nos pinos de E / S quando eles são configurados como entradas. Isso significa que as chaves podem simplesmente ter um pólo conectado ao aterramento (LO) e o outro pólo conectado a uma entrada do processador. O primeiro exemplo mostra apenas duas opções. Os interruptores são lidos e configurados com o seguinte código. Configure os interruptores como entradas: (Nenhum código necessário; este é o padrão.) Ligue os resistores pull-up: PORTB = _BV (PB0) | _BV (PB1); Leia as entradas: but1 = ~ PINB & 0x03; Observe o uso de inversão e mascaramento para obter o valor correto.

Etapa 2: luzes piscantes para um sinal

Usaremos esses dois interruptores para piscar um LED um número programável de vezes. Os LEDs que usaremos serão as luzes piscantes que o The Real Elliot popularizou. Os interruptores 1 e 2 serão tratados como dois dígitos binários, de modo que a combinação pode representar os números 0, 1, 2 e 3. Nosso programa lerá os dois interruptores e piscará o LED o número apropriado de vezes, mas somente se o interruptor as configurações foram alteradas. Os interruptores são depurados por 500 milissegundos (não otimizado). O algoritmo de debounce é bastante simples. Os interruptores são lidos e a leitura é anotada. Se for diferente do valor oldBut (o último valor salvo), o programa é atrasado por 500 milissegundos e as chaves são lidas novamente. Se o valor for igual ao lido anteriormente, o valor de oldBut será atualizado e o LED piscará o número de vezes implícito pelo valor binário das duas chaves. Observe a inversão do valor, pois uma chave que está "ligada" lê LO. Os interruptores serão examinados continuamente em busca de novas alterações. Consulte os Instructables anteriores do The Real Elliot para saber mais sobre luzes piscantes. Dê uma olhada neste https://www.ganssle.com/debouncing.pdf para aprender mais sobre debouncing switches. Aqui está o código ATtiny2313 para este exemplo. Em operação, este programa piscará o LED no PB4 (pino físico 8) duas vezes para mostrar que foi inicializado. Em seguida, ele lerá os interruptores um e dois e piscará de uma a três vezes, dependendo da configuração do interruptor, sempre que forem alterados. Quando as chaves não estão mudando, o LED piscará lentamente. Para executar este código, crie um novo diretório (chame-o de "Básico" se desejar) e baixe o seguinte arquivo de código C e makefile nele. Renomeie Makefile1.txt para apenas Makefile. Usando o WinAVR, compile o programa e carregue-o em seu ATtiny2313.

Etapa 3: Uma pequena digressão sobre depuração

Se você for como eu (e todos os outros programadores no mundo), provavelmente já passou por momentos em que o código "livre de erros" que você digitou e compilou cuidadosamente não faz o que você espera. Talvez simplesmente não faça nada! Então qual é o problema? Como você vai descobrir? Felizmente, existem várias abordagens para fazer as coisas funcionarem. (Obtenha este livro para um excelente tratamento do tópico de depuração. Http://www.debuggingrules.com/) Eu gostaria de oferecer algumas sugestões simples relativas ao tópico de depuração de aplicativos de microcontroladores. A etapa um é desenvolver o que você sabe. Se você conseguiu que um pisca-pisca funcionasse uma vez, use-o novamente para ver onde você está no programa. Gosto que o LED pisque duas vezes para sinalizar o início do programa. Você pode colocar o código para fazer isso inicialmente no início do programa. Depois de saber que não há nada de errado com seu hardware, crie uma função para fazer o piscar. Aqui está a função que eu uso./*------------------------------------------ ------------------------------ ** blinkEm - função para piscar o LED usando PD4 ** PD4 deve ser configurado como uma saída. ** ------------------------------------------------ --------------------- * / void blinkEm (uint8_t count) {while (count> 0) {PORTD = _BV (PD4); _delay_ms (1000); PORTD = ~ _BV (PD4); _delay_ms (1000); contar--; }} Agora é possível usar esta função em vários pontos do seu código como um sinal de que o código foi executado até agora. Saber que o código está sendo executado significa que você pode examinar cuidadosamente cada seção que foi executada, mas não fez o que você esperava, para encontrar erros. Alterar uma coisa de cada vez é uma técnica chave para depuração também (descrita na referência acima). Este método clássico funciona junto com "dividir para conquistar": dar pequenos passos para adicionar funcionalidade aos poucos. Isso pode parecer uma abordagem lenta, mas não é tão lenta quanto tentar depurar uma grande seção de código que não funciona de uma vez.

Etapa 4: mais depuração

Muitas vezes queremos verificar uma seção do código, pulando a maioria das linhas nela e, em seguida, ativando-as uma de cada vez enquanto verificamos que cada uma funciona. Normalmente, fazemos isso "comentando" as linhas que desejamos pular. Uma extensão dessa técnica é cortar e colar um bloco de código, comentar o original (para não perdê-lo) e hackear a cópia. O C tem quatro maneiras fáceis de comentar as linhas. Colocar "//" na frente de uma linha comenta essa linha. Fechar uma ou mais linhas em "/ *" e "* /" comentará uma seção inteira. Para que esse método funcione efetivamente, não deve haver nenhum outro "* /" no bloco de código (além do final). Portanto, uma disciplina eficaz é usar // para comentários dentro de blocos de código e reservar a construção / * * / para blocos de comentários e para comentar as seções do código. Colocando "#if 0" no início de um bloco para comentar e terminando a seção com "#endif". Mais controle seletivo é possível usando "#ifdef (identificador)" no início de um bloco e "#endif" no final. Se você quiser que o bloco seja compilado, use "#define (identificador)" anteriormente no programa. Observe que as aspas são apenas para ênfase e não devem ser incluídas. A combinação dessas técnicas deve fornecer uma abordagem útil para depurar seus programas ATtiny2313. Você pode achar essas ferramentas úteis à medida que prosseguirmos neste Instructable.

Etapa 5: usando o cronômetro / contador 0 para bipes

O ATtiny2313 possui dois poderosos recursos de temporizador / contador: um de 8 bits e outro de 16 bits. Eles podem ser configurados como geradores de frequência, controladores de modulação de largura de pulso variável e registradores de comparação de saída. A funcionalidade completa deles é descrita em 49 páginas da folha de dados. No entanto, usaremos um caso simples. Apenas o Timer / Counter 0 (o de 8 bits) será usado e será usado simplesmente como um gerador de frequência. A frequência será direcionada para um pequeno alto-falante para produzir um bipe. O temporizador / contador 0 é totalmente descrito nas páginas 66 a 83 da folha de dados ATtiny2313. Uma leitura atenta deste material fornecerá uma compreensão completa do tempo / contador 0. Felizmente, um modo bastante simples, Clear Timer on Compare (CTC), é tudo o que é necessário para gerar o sinal sonoro que desejamos.

Para o modo que usaremos, a operação do Timer / Contador é direta. Quando um sinal de clock é selecionado, o contador começa em zero e incrementa cada pulso de clock. Quando o valor do contador atinge o valor no Registro de comparação de saída (TOP), o contador é zerado e a contagem começa novamente. O bit de saída associado ao Timer / Contador é alternado para produzir uma saída de onda quadrada. Isso aciona diretamente um transdutor de áudio para fazer um som de bipe. Um pequeno transdutor de áudio TDK produz o bipe. Uma unidade adequada é Digikey 445-2530-ND, TDK SD1209T3-A1 (usei uma versão anterior deste). Esta é uma versão de 3 volts; a versão de 5 volts também funcionará, eu espero. Eu dirijo isso diretamente da porta de saída do Attiny2313 e parece funcionar bem. Sparkfun tem um dispositivo semelhante.

Etapa 6: Configurando Timer / Contador 0

O modo CTC pode ser usado para alternar a saída OC0A no pino 2, porta B (pino físico 14). Para habilitar a saída neste pino, o DDRB deve ser configurado apropriadamente. O código C para isso é como configurar uma saída para uma luz intermitente. DDRB = _BV (PB2); // A porta B2 é uma saída. A próxima etapa é fornecer um sinal de clock e carregar o registrador de comparação de saída para produzir uma forma de onda como uma frequência. A equação para a frequência resultante é fornecida na planilha de dados (página 72). Os termos da equação serão descritos a seguir. Aqui está a equação: fOC0A = fclk_I / O / 2 * N * (1 + OCR0A) Onde fOC0A: = frequência de saída fclk_I / O: = frequência da fonte de relógio N: = fator de pré-escala de relógio OCR0A: = valor no registro de comparação de saída para Timer / Contador 0A. Frequência da fonte do relógio, fclk_I / OTesta é a frequência do relógio do sistema. O valor padrão é 1MHz. Os bits CS00, CS01 e CS02 de TCCR0B controlam essa seleção. Uma vez que esses bits também selecionam o valor de N, ele é descrito a seguir. Valor do predecessor, NN é o valor usado para dividir, ou pré-escalar, o relógio do sistema. Os bits CS00, CS01 e CS02 de TCCR0B controlam essa seleção. A Tabela 41 na página 81 da folha de dados ATtiny2313 descreve as combinações. Como uma frequência próxima a 1kHz é desejada, os bits CS00 e CS01 de TCCR0B serão definidos. Observe que definir todos os três bits como 0, sem selecionar nenhuma fonte de relógio, efetivamente interrompe a saída. Este é o método que será usado para iniciar e parar o bipe. Valor TOP, OCR0Este valor é o valor SUPERIOR para o contador que é carregado no Registrador de Comparação de Saída para Timer / Contador 0A. Quando este valor for atingido, o contador será zerado e a contagem começará novamente até que o TOPO seja alcançado e o ciclo se repita. TOP é facilmente modificado, então a frequência do bíper é fácil de mudar. Como uma frequência próxima de 1kHz é desejada, TOP é definido como 7. (Observe que o prescaler pode ter sido definido como 8 e TOP como 63. O mesmo resultado - sua escolha.) Frequência de saída, fOC0AUsando a equação para calcular os resultados da frequência de saída in: fOC0A = 1, 000, 000/2 * 64 * (1 + 7) fOC0A = 977 Hz Perto o suficiente! Aqui está o código para carregar o registro de comparação de saída e o registro de controle do contador do temporizador 0B. Consulte o código do programa real para entender como eles são usados. OCR0A = 7; // Valor de tempo TCCR0B = _BV (CS01) | _BV (CS00); // Selecione o relógio interno & prescale = 8 TCCR0B = 0; // nenhuma fonte de relógio desliga o tom Definindo o modo de tempo / contador Como último detalhe, especificaremos o modo de temporizador / contador que desejamos definindo os bits apropriados no Registro de controle de temporizador / contador 0A. O modo CTC é selecionado definindo o bit WGM01 conforme descrito na Tabela 40, página 79 da planilha de dados. Como queremos que a saída alterne a cada ciclo, o bit COM0A0 também precisa ser definido conforme descrito na Tabela 34 na página 77. Aqui está o código: TCCR0A = _BV (COM0A0) | _BV (WGM01); // Modo Alternar CTC

Etapa 7: usando quatro interruptores

À medida que implementamos o sinal sonoro, vamos estender nosso hardware e software para lidar com quatro interruptores. Uma vez que a saída do contador do temporizador 0A está na porta B, pino 2, não podemos simplesmente conectar mais interruptores sequencialmente à porta B. Uma solução fácil seria usar a porta D, mas vamos manter essa porta disponível para outras funções (talvez um motor de passo). Portanto, vamos conectar os switches adicionais a PB3 e PB4. A leitura dos switches permanece praticamente inalterada. O valor da máscara é alterado para 0x1B (00011011 binário) para mascarar o bit 2 junto com 5, 6 e 7. Outro truque é usado para criar um número binário de 4 bits. Desloque os bits 3 e 4 para a direita um bit e combine-os com os bits 0 e 1 em um número binário de 4 bits. Esta é a sintaxe C padrão para trocar e combinar bits, mas pode não ser bem conhecida para o novato. but1a = (but1 & 0x03) | ((but1 & 0x18) >> 1); // but1 tem a chave readingIn operation, o programa piscará duas vezes e emitirá dois bipes para sinalizar a inicialização. Sempre que os interruptores forem alterados, o número que eles representam emitirá um bipe. Quando as chaves não estão mudando, o LED piscará. Para executar este código, crie um novo diretório (chame-o de Beep se desejar) e baixe o seguinte arquivo de código C e makefile nele. Renomeie Makefile2.txt para apenas Makefile. Usando o WinAVR, compile o programa e carregue-o em seu Attiny2313.

Etapa 8: Usando a construção de switch / case

A etapa final é "apenas software": conforme prometido, implementaremos a construção switch / case. Embora este exemplo mostre apenas duas ações alternativas, deve estar muito claro como usar essa construção para selecionar uma das várias seções de código alternativas. Em operação, este programa monitora as chaves e se houver uma alteração, ele emitirá um bipe com o número apropriado se for ímpar; ele piscará se o número for par. Ele não faz nada a menos que um switch mude.

Para executar este código, crie um novo diretório (chame-o de Switch se desejar) e baixe o seguinte arquivo de código C e makefile nele. Renomeie Makefile3.txt para apenas Makefile. Usando o WinAVR, compile o programa e carregue-o em seu Attiny2313.

Etapa 9: Conclusão

Então é isso! Agora você sabe como usar interruptores para controlar a execução de seu programa, lendo-os e selecionando uma ação com base na configuração do interruptor. Você também sabe como criar um tom de bipe e também aprendeu algumas estratégias de depuração.

Se você gostaria de testar sua compreensão, tente modificar o último programa para emitir um bipe em tom alto, se par, bipe uma nota baixa se estranho, e piscar o LED continuamente se não houver mudança nos interruptores. Você pode querer olhar de volta à seção sobre depuração para obter ajuda.