Interruptores de lectura con ATtiny2313: 9 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:45

Ha habido varios Instructables relacionados con las salidas del ATtiny2313 y dispositivos AVR similares. Por ejemplo, https://www.instructables.com/id/Ghetto-Programming%3a-Getting-started-with-AVR-micro/, https://www.instructables.com/id/Drive-a-Stepper- Motor-con-un-microprocesador-AVR /. Trabajando en el último de The Real Elliot, que mostraba cómo controlar motores paso a paso, descubrí que sería realmente útil poder ejecutar secciones alternativas de código en el mismo programa para no tener que reprogramar el ATtiny2313 cada uno. vez que quería probar una ligera variación de código (como medio paso o ejecutar el paso a paso en reversa). Si bien es fácil escribir código usando una declaración de cambio / caso para permitir la selección de variaciones alternativas, se necesita alguna forma de seleccionar el caso. Eso significa que se debe leer algún tipo de dispositivo de entrada para controlar el caso. Afortunadamente, el ATtiny2313 tiene muchos pines de E / S y está bien diseñado para leer las entradas de los interruptores. Este Instructable mostrará cómo leer las entradas y tomar decisiones en función de su estado. Dado que solo eso haría un Instructable bastante aburrido, explicaré una forma simple de usar la capacidad de temporizador / contador del ATtiny2313 para manejar un pequeño altavoz como un beeper. También habrá una pequeña digresión sobre técnicas simples de depuración.

Paso 1: el dispositivo de entrada

Este Instructable se basa en el excelente trabajo de The Real Elliot y utiliza el sistema de desarrollo ATtiny2313 Ghetto que describe. La hoja de datos ATtiny2313 de Atmel es la última referencia para todas las funciones, pero no es necesariamente fácil de leer. https://www.atmel.com/dyn/products/datasheets.asp?family_id=607 (El enlace tiene todas las hojas de datos del AVR, ubique el 2313). La figura muestra un conjunto simple de interruptores de entrada. Este es simplemente un paquete de cuatro interruptores de encendido / apagado; también conocidos como interruptores unipolares y de un solo tiro (SPST). Por lo general, una conexión, o polo, de cada interruptor está conectado a tierra mientras que la otra conexión se eleva a través de una resistencia limitadora de corriente (aproximadamente 10 K). Una entrada de microcontrolador está conectada al polo con la resistencia. Si el interruptor está abierto, el microcontrolador leerá la entrada como HI. Si el interruptor está cerrado, el microcontrolador leerá la entrada LO. Consulte el esquema para obtener más detalles. El ATtiny2313 simplifica las cosas al proporcionar resistencias pull-up programables en los pines de E / S cuando se configuran como entradas. Esto significa que los interruptores pueden simplemente tener un polo conectado a tierra (LO) y el otro polo conectado a una entrada de procesador. El primer ejemplo muestra solo dos interruptores. Los interruptores se leen y configuran con el siguiente código. Configure los interruptores como entradas: (No se requiere código; este es el predeterminado.) Encienda las resistencias pull-up: PORTB = _BV (PB0) | _BV (PB1); Leer las entradas: but1 = ~ PINB & 0x03; Tenga en cuenta el uso de inversión y enmascaramiento para obtener el valor correcto.

Paso 2: luces intermitentes para una señal

Usaremos estos dos interruptores para hacer parpadear un LED un número programable de veces. Los LED que usaremos serán las luces intermitentes que hizo famoso The Real Elliot. Los interruptores 1 y 2 se tratarán como dos dígitos binarios, por lo que la combinación puede representar los números 0, 1, 2 y 3. Nuestro programa leerá los dos interruptores y hará parpadear el LED el número apropiado de veces, pero solo si el interruptor la configuración ha cambiado. Los interruptores se eliminan durante 500 milisegundos (no optimizados). El algoritmo antirrebote es bastante simple. Se leen los interruptores y se anota la lectura. Si es diferente del valor de oldBut (el último valor guardado), el programa se retrasa 500 milisegundos y los interruptores se leen de nuevo. Si el valor es el mismo que el leído anteriormente, el valor de oldBut se actualizará y el LED parpadeará el número de veces que implica el valor binario de los dos interruptores. Note la inversión del valor ya que un interruptor que está "encendido" lee LO. Los interruptores se escanearán continuamente en busca de cambios adicionales. Consulte los Instructables anteriores de The Real Elliot para obtener más información sobre las luces intermitentes. Eche un vistazo a este https://www.ganssle.com/debouncing.pdf para obtener más información sobre los interruptores antirrebote. Aquí está el código ATtiny2313 para este ejemplo. En funcionamiento, este programa hará parpadear el LED en PB4 (pin físico 8) dos veces para mostrar que está inicializado. Luego leerá los interruptores uno y dos, y parpadeará de una a tres veces dependiendo de la configuración del interruptor cada vez que se cambien. Cuando los interruptores no cambian, el LED parpadeará lentamente. Para ejecutar este código, cree un nuevo directorio (llámelo "Básico" si lo desea) y descargue el siguiente archivo de código C y makefile en él. Cambie el nombre de Makefile1.txt a solo Makefile. Usando WinAVR, compile el programa y cárguelo en su ATtiny2313.

Paso 3: una pequeña digresión sobre la depuración

Si usted es como yo (y cualquier otro programador del mundo), probablemente haya experimentado momentos en los que el código "libre de errores" que ha escrito y compilado cuidadosamente no hace lo que espera que haga. ¡Quizás simplemente no hace nada! ¿Entonces, cuál es el problema? ¿Cómo vas a averiguarlo? Afortunadamente, existen varios enfoques para hacer que las cosas funcionen. (Obtenga este libro para un excelente tratamiento del tema de la depuración. Http://www.debuggingrules.com/) Me gustaría ofrecer algunas sugerencias simples relacionadas con el tema de la depuración de aplicaciones de microcontroladores. lo que sabes. Si ha conseguido que una luz intermitente funcione una vez, úsela de nuevo para ver dónde se encuentra en su programa. Me gusta que el LED parpadee dos veces para indicar el inicio del programa. Puede poner el código para hacer esto inicialmente al comienzo de su programa. Una vez que sepa que no hay ningún problema con su hardware, cree una función para hacer el parpadeo. Aquí está la función que uso./*------------------------------------------ ------------------------------ ** blinkEm - función para hacer parpadear el LED usando PD4 ** PD4 debe configurarse como una salida. ** ------------------------------------------------ --------------------- * / void blinkEm (uint8_t count) {while (count> 0) {PORTD = _BV (PD4); _delay_ms (1000); PORTD = ~ _BV (PD4); _delay_ms (1000); contar--; }} Ahora es posible usar esta función en varios puntos de su código como una señal de que el código se ha ejecutado hasta ese momento. Saber que el código se está ejecutando significa que puede examinar cuidadosamente cada sección que se ha ejecutado, pero que no hizo lo que esperaba, para encontrar errores. Cambiar una cosa a la vez es una técnica clave para la depuración también (descrita en la referencia anterior). Este método clásico funciona junto con "divide y vencerás": dar pequeños pasos para agregar funcionalidad de manera incremental. Esto puede parecer un enfoque lento, pero no es tan lento como tratar de depurar una gran sección de código que no funciona de una vez.

Paso 4: más depuración

Hay muchas ocasiones en las que queremos verificar una sección de código omitiendo la mayoría de las líneas y luego habilitándolas una a la vez a medida que verificamos que funcionan. Normalmente, hacemos esto "comentando" las líneas que queremos omitir. Una extensión de esta técnica es cortar y pegar un bloque de código, comentar el original (para que no lo perdamos) y cortar la copia. C tiene cuatro formas sencillas de comentar líneas. Poner "//" delante de una línea comenta esa línea. Si encierra una o más líneas en "/ *" y "* /" se comentará una sección completa. Para que este método funcione eficazmente, no debe haber ningún otro "* /" en el bloque de código (aparte del final). Entonces, una disciplina efectiva es usar // para comentarios dentro de bloques de código, y reservar la construcción / * * / para bloques de comentarios y para comentar secciones de código. Colocando "#if 0" al comienzo de un bloque para comentar y terminando la sección con "#endif". Es posible un control más selectivo usando "#ifdef (identificador)" al comienzo de un bloque y "#endif" al final. Si desea que el bloque se compile, use "#define (identifier)" anteriormente en el programa. Tenga en cuenta que las comillas son solo para enfatizar y no deben incluirse. La combinación de estas técnicas debería proporcionar un enfoque útil para depurar sus programas ATtiny2313. Puede encontrar estas herramientas útiles a medida que avanzamos en este Instructable.

Paso 5: Uso del temporizador / contador 0 para pitidos

El ATtiny2313 tiene dos potentes recursos de temporizador / contador: uno de 8 bits y otro de 16 bits. Estos pueden configurarse como generadores de frecuencia, controladores de modulación de ancho de pulso variable y registros de comparación de salida. La funcionalidad completa de estos se describe en 49 páginas de la hoja de datos. Sin embargo, usaremos un caso simple. Solo se utilizará el Temporizador / Contador 0 (el de 8 bits) y se utilizará simplemente como generador de frecuencia. La frecuencia se enviará a un pequeño altavoz para producir un pitido. El temporizador / contador 0 se describe completamente en las páginas 66 a 83 de la hoja de datos de ATtiny2313. Una lectura atenta de este material le proporcionará una comprensión completa de Time / Counter 0. Afortunadamente, un modo bastante simple, Clear Timer on Compare (CTC), es todo lo que se requiere para generar el tono de bip que queremos.

Para el modo que usaremos, el funcionamiento del temporizador / contador es sencillo. Cuando se selecciona una señal de reloj, el contador comienza en cero e incrementa cada pulso de reloj. Cuando el valor del contador alcanza el valor en el registro de comparación de salida (TOP), el contador se restablece a cero y el conteo comienza de nuevo. El bit de salida asociado con el temporizador / contador se alterna para producir una salida de onda cuadrada. Esto impulsa directamente un transductor de audio para que emita un pitido. Un pequeño transductor de audio TDK produce el pitido. Una unidad adecuada es Digikey 445-2530-ND, TDK SD1209T3-A1 (utilicé una versión anterior de esto). Esta es una versión de 3 voltios; la versión de 5 voltios también funcionará, espero. Conduzco esto directamente desde el puerto de salida del Attiny2313 y parece funcionar bien. Sparkfun tiene un dispositivo similar.

Paso 6: Configuración del temporizador / contador 0

El modo CTC se puede utilizar para alternar la salida OC0A en el pin 2, puerto B (pin físico 14). Para habilitar la salida en este pin, DDRB debe configurarse apropiadamente. El código C para esto es como configurar una salida para una luz intermitente. DDRB = _BV (PB2); // El puerto B2 es una salida. El siguiente paso es suministrar una señal de reloj y cargar el registro de comparación de salida para producir una forma de onda como frecuencia. La ecuación para la frecuencia resultante se da en la hoja de datos (página 72). Los términos de la ecuación se describirán a continuación. Aquí está la ecuación: fOC0A = fclk_I / O / 2 * N * (1 + OCR0A) Donde fOC0A: = frecuencia de salida fclk_I / O: = frecuencia de la fuente de reloj N: = factor de preescala del reloj OCR0A: = valor en el registro de comparación de salida para el temporizador / Contador 0A. Frecuencia de la fuente del reloj, fclk_I / O Esta es la frecuencia del reloj del sistema. El valor predeterminado es 1 MHz. Los bits CS00, CS01 y CS02 de TCCR0B controlan esta selección. Dado que estos bits también seleccionan el valor de N, se describe a continuación. Valor de preescalador, NN es el valor utilizado para dividir, o preescalar, el reloj del sistema. Los bits CS00, CS01 y CS02 de TCCR0B controlan esta selección. La Tabla 41 en la página 81 de la hoja de datos de ATtiny2313 describe las combinaciones. Dado que se desea una frecuencia cercana a 1 kHz, se establecerán los bits CS00 y CS01 de TCCR0B. Tenga en cuenta que establecer los tres bits en 0, por lo que no se selecciona ninguna fuente de reloj, detiene efectivamente la salida. Este es el método que se utilizará para iniciar y detener el pitido. Valor SUPERIOR, OCR0A Este valor es el valor SUPERIOR del contador que se carga en el Registro de comparación de salida para el temporizador / contador 0A. Cuando se alcanza este valor, el contador se restablecerá a cero y el conteo comenzará nuevamente hasta que se alcance TOP y el ciclo se repita. TOP se modifica fácilmente, por lo que la frecuencia del zumbador es fácil de cambiar. Dado que se desea una frecuencia cercana a 1 kHz, TOP se establece en 7. (Tenga en cuenta que el preescalador podría haberse configurado en 8 y TOP en 63. El mismo resultado: su elección). Frecuencia de salida, fOC0A Uso de la ecuación para calcular los resultados de la frecuencia de salida in: fOC0A = 1, 000, 000/2 * 64 * (1 + 7) fOC0A = 977Hz ¡Lo suficientemente cerca! Aquí está el código para cargar el registro de comparación de salida y el registro de control del contador del temporizador 0B. Consulte el código del programa real para comprender cómo se utilizan. OCR0A = 7; // Valor temporal TCCR0B = _BV (CS01) | _BV (CS00); // Seleccionar reloj interno & prescale = 8 TCCR0B = 0; // ninguna fuente de reloj apaga el tono Configuración del modo de tiempo / contador Como último detalle, especificaremos el modo de temporizador / contador que deseamos configurando los bits apropiados en el registro de control de temporizador / contador 0A. El modo CTC se selecciona configurando el bit WGM01 como se describe en la Tabla 40, página 79 de la hoja de datos. Como queremos que la salida alterne cada ciclo, el bit COM0A0 también debe configurarse como se describe en la Tabla 34 en la página 77. Aquí está el código: TCCR0A = _BV (COM0A0) | _BV (WGM01); // Modo de alternancia de CTC

Paso 7: uso de cuatro interruptores

A medida que implementamos el beeper, ampliemos nuestro hardware y software para manejar cuatro interruptores. Dado que la salida del contador de temporizador 0A está en el puerto B, pin 2, no podemos simplemente conectar más conmutadores secuencialmente al puerto B. Una solución fácil sería usar el puerto D, pero mantengamos ese puerto disponible para otras funciones (tal vez un motor paso a paso). Así que conectemos los conmutadores adicionales a PB3 y PB4. La lectura de los conmutadores prácticamente no ha cambiado. El valor de la máscara se cambia a 0x1B (00011011 binario) para enmascarar el bit 2 junto con 5, 6 y 7. Se utiliza un truco más para crear un número binario de 4 bits. Desplace los bits 3 y 4 a la derecha un bit y combínelos con los bits 0 y 1 en un número binario de 4 bits. Esta es la sintaxis estándar de C para cambiar y combinar bits, pero es posible que los principiantes no la conozcan bien. but1a = (but1 y 0x03) | ((pero1 y 0x18) >> 1); // pero1 tiene lectura de interruptor En funcionamiento, el programa parpadeará dos veces y pitará dos veces para señalar la inicialización. Cada vez que se cambian los interruptores, el número que representan sonará. Cuando los interruptores no cambian, el LED parpadeará. Para ejecutar este código, cree un nuevo directorio (llámelo Beep si lo desea) y descargue el siguiente archivo de código C y makefile en él. Cambie el nombre de Makefile2.txt a solo Makefile. Usando WinAVR, compile el programa y cárguelo en su Attiny2313.

Paso 8: Uso de la construcción Switch / case

El paso final es "solo software": como se prometió, implementaremos la construcción switch / case. Aunque este ejemplo solo muestra dos acciones alternativas, debe quedar muy claro cómo usar esta construcción para seleccionar una de varias secciones de código alternativas. En funcionamiento, este programa monitorea los interruptores y si hay un cambio, emitirá un bip en el número apropiado si es impar; parpadeará si el número es par. No hace nada a menos que cambie un interruptor.

Para ejecutar este código, cree un nuevo directorio (llámelo Switch si lo desea) y descargue el siguiente archivo de código C y makefile en él. Cambie el nombre de Makefile3.txt a solo Makefile. Usando WinAVR, compile el programa y cárguelo en su Attiny2313.

Paso 9: Conclusión

¡Eso es todo! Ahora sabe cómo usar interruptores para controlar la ejecución de su programa leyéndolos y seleccionando una acción basada en la configuración del interruptor. También sabe cómo crear un tono de pitido y también ha aprendido algunas estrategias de depuración.

Si desea probar su comprensión, intente modificar el último programa para que emita un pitido en un tono alto si es par, emita un pitido bajo si es impar y haga parpadear el LED continuamente si no hay cambios en los interruptores. de nuevo en la sección de depuración para obtener ayuda.