🔸 🍙 🥂 Programación de bajo nivel de microcontroladores de la serie TinyAVR 0 👧 🚚 👨🏽‍🔧

¿Es usted un programador de 8 o 32 bits? En OMZLO hemos centrado nuestros esfuerzos en los nuevos chips ARM Cortex de 32 bits (STM32 y SAMD), que, en comparación con los microcontroladores más antiguos de 8 bits (Micro Controller Units, MCU), suelen ofrecer más RAM y mejor rendimiento. , soporte para más periféricos. Y todo esto, por lo mismo o por un precio menor. Pero las MCU de 8 bits aún no han perdido su relevancia. En particular, Microchip ha lanzado una nueva serie de chips, "tinyAVR 0-series", que, en comparación con los chips AVR lanzados anteriormente, permiten trabajar con periféricos más modernos. Al mismo tiempo, los nuevos chips se distinguen por un precio muy atractivo. Parece que estos chips son perfectos para desarrollar dispositivos simples que no necesitan las capacidadeslo que ofrecen las nuevas MCU de 32 bits. Además, los microcontroladores de 8 bits son mucho más fáciles de programar, lo que conduce a un aumento en la velocidad de desarrollo de la parte de software de los dispositivos creados sobre su base.

Gracias al éxito del Arduino UNO, hay muchos tutoriales en Internet que explican las características de programación de los microcontroladores ATmega328 de 8 bits y sus contrapartes como el ATtiny85. Estamos hablando de acceso directo a registros sin usar el lenguaje de programación usado para Arduino, y sin usar IDE creados por fabricantes de chips como Atmel Studio. Para verificar esto, simplemente busque en Google "atmega328 blinky". Para programar microcontroladores solo necesita un compilador C para AVR, un editor de texto, avrdude y un programador AVR. En algunos recursosincluso se pueden encontrar guías sobre cómo poner en funcionamiento el ATmega328 con placas de prueba universales. Es cierto que si hablamos de los nuevos chips de la serie 0 de tinyAVR, no es fácil encontrar información de este tipo en ellos.

Por supuesto, Microchip ofrece todas las herramientas que necesita para programar el nuevo tinyAVR en un IDE diseñado exclusivamente para Windows. Para algunos de los chips más nuevos, existen "núcleos Arduino". Gracias a esto, dichos chips se pueden programar usando el IDE de Arduino. Pero, de nuevo, si uno prefiere escribir código de microcontrolador en un estilo de "bajo nivel" usando su editor de texto favorito Makefiley compilador de C, entonces encontrará muy poca información sobre este enfoque para trabajar con tinyAVR.

En este artículo te contamos cómo, desde cero, utilizando las herramientas más sencillas, crear firmware blinkypara ATtiny406. La mayor parte de lo que se discutirá también es cierto para otros microcontroladores de AVR diminutos. Este tutorial está destinado a quienes usan macOS y Linux, pero nuestro consejo, con pequeñas modificaciones, también será útil para quienes usan el entorno Windows.

Parte de hardware del proyecto

▍Investigación ATtiny406

Decidimos experimentar con el ATtiny406 , esperando que en el futuro este microcontrolador reemplace al ATtiny45, que se usa actualmente en el PiWatcher , en nuestro desarrollo, lo que permite, cuando surge tal necesidad, apagar o reiniciar completamente la Raspberry Pi. El ATtiny406 tiene 4 KB de memoria flash, 256 bytes de RAM, el microchip puede operar a 20 MHz sin una fuente de reloj externa.

Una de las principales diferencias entre las nuevas MCU tinyAVR y los chips más antiguos y conocidos como el ATtiny85 es que los chips más nuevos utilizan el protocolo de programación UPDI. Solo necesita 3 pines para funcionar, y se necesitan 6 pines para el protocolo ISP utilizado por chips antiguos.

Después de un breve estudio de la pregunta, nos enteramos de que puede programar tinyAVR con UPDI utilizando un simple cable USB a serie y una resistencia. Descubrimos esto gracias a la herramienta pyupdi Python , que sugirió el siguiente diagrama de cableado para cargar firmware a un microcontrolador.

Diagrama de conexión del microcontrolador

▍Diseño de tablero para ATtiny406

Hemos creado una placa de arranque minimalista para el ATtiny406. Esta placa puede ser alimentada por 5V desde USB. Alternativamente, puede aplicarle un voltaje más bajo de 3.3V usando los pines dedicados VCC / GND. Hay un lugar para un botón y un LED en el tablero. Para realizar experimentos, decidimos construir una resistencia de 4,7 kOhmios en la placa, que se requiere para usar el protocolo UPDI (esta es la resistencia R2). Como resultado, obtuvimos el siguiente diseño de placa.

Disposición del tablero

▍Tablero terminado

La placa de conexión terminada resultó ser bastante compacta, encaja bien en una placa de pruebas pequeña. Los esquemas de la placa se pueden encontrar aquí .

Placa posterior montada en una placa prototipo

Para programar el ATtiny406, se conecta un cable USB a serie a la placa mediante las clavijas que tiene.

Diagrama de conexión de cables

La parte de software del proyecto

▍pyupdi

Instalamos pyupdi siguiendo las instrucciones del repositorio del proyecto .

El cable USB a serie se conectó a la placa mediante cuatro pines UPDI. Nuestro convertidor de USB a serie se consideró en macOS como un /dev/tty.usbserial-FTF5HUAV.

Para asegurarse de que el programador reconozca el ATtiny406, puede ejecutar un comando similar al siguiente editando la ruta del archivo:

pyupdi -d tiny406 -c /dev/tty.usbserial-FTF5HUAV -i

Si todo está configurado correctamente, la ejecución de un comando como este debería dar como resultado algo como esto:

Device info: {'family': 'tinyAVR', 'nvm': 'P:0', 'ocd': 'D:0', 'osc': '3', 'device_id': '1E9225', 'device_rev': '0.1'}

Compilador de ▍C

Resultó que el compilador avr-gcc normal que se puede instalar en macOS usando Homebrew no permite configurar ATtiny406 como un objetivo de compilación. Por lo tanto, decidimos instalar avr-gcc proporcionado por Microchip. Para descargar el compilador, debe crear una cuenta en el sitio web de Microchip, lo cual es un poco molesto.

Descarga del compilador

Después de descargar los materiales necesarios presentados en forma de archivo, descomprimimos este archivo en una carpeta separada. Sebindebe agregar laruta al directorioque estará en esta carpetaPATH. Esto facilitará el trabajo en el futuro. Suponiendo que el compilador está almacenado en una carpeta$HOME/Src/avr8-gnu-toolchain-darwin_x86_64,PATHpuedeeditarloagregando el siguiente comando al archivo.bash_profile:

export PATH=$PATH:$HOME/Src/avr8-gnu-toolchain-darwin_x86_64/bin/

Los MCU ATtiny más nuevos no son compatibles con el compilador avr-gcc de Microchip sin una configuración adicional. Para admitirlos , debe descargar ATtiny Device Pack .

Descarga de ATtiny Device Pack

Como resultado, descargamos el paqueteAtmel.ATtiny_DFP.1.6.326.atpack(este archivo puede tener un nombre diferente, su nombre puede incluir un número de versión diferente). Aunque la extensión del archivo es. atpack, este es en realidad un.ziparchivonormal. Cambiamos su extensión.zipay extrajimos el contenido del paquete a una carpeta$HOME/Src/Atmel.ATtiny_DFP.1.6.326, es decir, al mismo lugar donde ya estaban los archivos del compilador.

▍Escribir un programa en C

Escribimos el siguiente programa, que, a una frecuencia de 1 Hz, hace parpadear el LED conectado al pin B5 de nuestra placa ATtiny.

#include <avr/io.h>
#include <util/delay.h>

int main() {
    _PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, 0); //   20 (,   0x02   2)

    PORTB.DIRSET = (1<<5);
    for (;;) {
        PORTB.OUTSET = (1<<5);
        _delay_ms(500);
        PORTB.OUTCLR = (1<<5);
        _delay_ms(500);
    }
}

Este código es muy similar al programa de parpadeo de LED escrito para microcontroladores AVR conocidos. El primer cambio notable es el uso de estructuras para acceder a los registros de MCU. Por ejemplo, en lugar de hacer referencia a PORTBuna referencia a PORTB.DIRSET.

Otro cambio está representado por el código de ajuste de frecuencia (_PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, 0)). El nuevo ATtiny406 corre a 3.33 MHz después de un reinicio, lo que corresponde a un reloj base de 20 MHz, que se divide por 6. Para que el chip funcione a la velocidad máxima de 20 MHz, borramos el registro CLKCTRL.MCLKCTRLB. Dado que este registro debe estar protegido contra cambios accidentales, en el ATtiny406, se debe utilizar una construcción de software especial para modificarlo. Afortunadamente, las macros facilitan esto _PROTECTED_WRITE. Puedes leer más sobre esto.aquí .

Si compara este código con el que está escrito para STM32 o SAMD21, resulta mucho más simple.

▍ Makefile

Aquí estamos usando la siguiente estructura de directorios:

src/Atmel.ATtiny_DFP.1.6.326/ - ruta a Microchip Device Pack.
src/attiny406-test/- la carpeta en la que, en el archivo main.c, se almacena el código anterior.

La compilación del código del directorio attiny406-test/se puede realizar con el siguiente comando:

avr-gcc -mmcu=attiny406 -B ../Atmel.ATtiny_DFP.1.6.326/gcc/dev/attiny406/ -O3 -I ../Atmel.ATtiny_DFP.1.6.326/include/ -DF_CPU=20000000L -o attiny406-test.elf main.c

La bandera le -Opermite realizar las optimizaciones necesarias para que las llamadas a la función funcionen correctamente _delay_ms(). Lo mismo ocurre con una variable -DF_CPUcuyo contenido refleja la frecuencia esperada del chip. El resto de los parámetros contienen información sobre la ubicación de los archivos del ATtiny406, que previamente descargamos y extrajimos del archivo Device Pack.

Para descargar el firmware a la MCU, debe convertir lo que tiene al formato Intel HEX. Después de eso, necesitas usar pyupdi. Hemos creado una Makefilesolución simple y automatizada para estas tareas:

OBJS=main.o
ELF=$(notdir $(CURDIR)).elf  
HEX=$(notdir $(CURDIR)).hex
F_CPU=20000000L

CFLAGS=-mmcu=attiny406 -B ../Atmel.ATtiny_DFP.1.6.326/gcc/dev/attiny406/ -O3
CFLAGS+=-I ../Atmel.ATtiny_DFP.1.6.326/include/ -DF_CPU=$(F_CPU)
LDFLAGS=-mmcu=attiny406 -B ../Atmel.ATtiny_DFP.1.6.326/gcc/dev/attiny406/
CC=avr-gcc
LD=avr-gcc

all:    $(HEX)  

$(ELF): $(OBJS)
                $(LD) $(LDFLAGS) -o $@ $(OBJS) $(LDLIBS)

$(HEX): $(ELF)
                avr-objcopy -O ihex -R .eeprom $< $@

flash:  $(HEX)
                pyupdi -d tiny406 -c /dev/tty.usbserial-FTF5HUAV -f attiny406-test.hex

read-fuses:
                pyupdi -d tiny406 -c /dev/tty.usbserial-FTF5HUAV -fr

clean:
                rm -rf $(OBJS) $(ELF) $(HEX)

Para compilar el código, simplemente ejecute el comando make. La descarga del código al microcontrolador se realiza mediante el comando make flash. Los enviados por nosotros Makefilepueden ser revisados, si es necesario.

Salir

Los nuevos TinyAVR son tan fáciles de programar como las generaciones anteriores de MCU. La clave es encontrar las herramientas adecuadas. Si tiene algún consejo para programar AVRTiny, compártalo con nosotros en Twitter o en los comentarios a continuación.

¿Está planeando utilizar el nuevo TinyAVR en sus proyectos?

Programación de bajo nivel de microcontroladores de la serie TinyAVR 0