👇 🤳🏿 📄 Programmation de bas niveau des microcontrôleurs tinyAVR série 0 🛌🏻 🎱 🈯️

Êtes-vous un programmeur 8 bits ou 32 bits? Chez OMZLO, nous nous sommes concentrés sur les nouvelles puces ARM Cortex 32 bits (STM32 et SAMD), qui offrent généralement plus de RAM et de meilleures performances que les anciens microcontrôleurs (MCU) 8 bits. , prise en charge de plus de périphériques. Et tout cela - pour la même chose ou pour un prix inférieur. Mais les MCU 8 bits n'ont pas encore perdu de leur pertinence. En particulier, Microchip a sorti une nouvelle série de puces, «tinyAVR 0-series», qui, en comparaison avec les puces AVR publiées plus tôt, permettent de travailler avec des périphériques plus modernes. Dans le même temps, les nouvelles puces se distinguent par un prix très attractif. Il semble que ces puces soient parfaites pour développer des appareils simples qui n'ont pas besoin des capacitésce que les nouveaux MCU 32 bits offrent. De plus, les microcontrôleurs 8 bits sont beaucoup plus faciles à programmer, ce qui entraîne une augmentation de la vitesse de développement de la partie logicielle des appareils créés sur leur base.

Grâce au succès de l'Arduino UNO, il existe de nombreux tutoriels sur Internet expliquant les fonctionnalités de programmation des microcontrôleurs 8 bits ATmega328 et de leurs homologues comme l'ATtiny85. Nous parlons d'accès direct aux registres sans utiliser le langage de programmation utilisé pour Arduino, et sans utiliser les IDE créés par des fabricants de puces comme Atmel Studio. Pour vérifier cela, recherchez simplement sur Google "atmega328 blinky". Pour programmer des microcontrôleurs, vous n'avez besoin que d'un compilateur C pour AVR, d'un éditeur de texte, d' avrdude et d'un programmeur AVR. Sur certaines ressourcesmême des guides peuvent être trouvés sur la façon de faire fonctionner l'ATmega328 avec des planches à pain universelles. Certes, si nous parlons des nouvelles puces de la série tinyAVR 0, il n'est pas facile de trouver des informations de ce type sur elles.

Bien entendu, Microchip offre tous les outils dont vous avez besoin pour programmer le nouveau tinyAVR dans un IDE conçu exclusivement pour Windows. Pour certaines des puces les plus récentes, il existe des «cœurs Arduino». Grâce à cela, ces puces peuvent être programmées à l'aide de l'IDE Arduino. Mais là encore, si l'on préfère écrire du code de microcontrôleur dans un style "bas niveau" en utilisant leur éditeur de texte Makefileet compilateur C préférés , alors ils trouveront très peu d'informations sur cette approche de travail avec tinyAVR.

Dans cet article, nous vous expliquerons comment, à partir de zéro, en utilisant les outils les plus simples, pour créer un firmware blinkypour ATtiny406. La plupart de ce qui sera discuté est également vrai pour les autres microcontrôleurs TinyAVR. Ce tutoriel est destiné à ceux qui utilisent macOS et Linux, mais nos conseils, avec des modifications mineures, seront également utiles pour ceux qui utilisent l'environnement Windows.

Partie matérielle du projet

▍Recherche ATtiny406

Nous avons décidé d'expérimenter avec l' ATtiny406 , en espérant qu'à l'avenir ce microcontrôleur remplacera l'ATtiny45, qui est actuellement utilisé dans PiWatcher - dans notre développement, qui permet, lorsqu'un tel besoin se fait sentir, d'éteindre complètement ou de redémarrer le Raspberry Pi. L'ATtiny406 dispose de 4 Ko de mémoire flash, 256 octets de RAM, la puce peut fonctionner à 20 MHz sans source d'horloge externe.

L'une des principales différences entre les nouveaux microcontrôleurs tinyAVR et les puces plus anciennes et bien connues comme l'ATtiny85 est que les nouvelles puces utilisent le protocole de programmation UPDI. Il n'a besoin que de 3 broches pour fonctionner, et 6 broches sont nécessaires pour le protocole ISP utilisé par les anciennes puces.

Après une brève étude du problème, nous avons appris que vous pouvez programmer tinyAVR avec UPDI en utilisant un simple câble USB-série et une résistance. Nous l'avons découvert grâce à l'outil pyupdi Python , qui a suggéré le schéma de câblage suivant pour télécharger le firmware sur un microcontrôleur.

Schéma de connexion du microcontrôleur

▍Board Design pour ATtiny406

Nous avons créé une carte de dérivation minimaliste pour l'ATtiny406. Cette carte peut être alimentée par 5V depuis USB. Vous pouvez également lui appliquer une tension inférieure de 3,3 V à l'aide des broches VCC / GND dédiées. Il y a une place pour un bouton et une LED sur la carte. Pour mener des expériences, nous avons décidé de construire une résistance de 4,7 kOhm dans la carte, ce qui est nécessaire pour utiliser le protocole UPDI (il s'agit de la résistance R2). En conséquence, nous avons obtenu la disposition de carte suivante.

Disposition du conseil

▍ Planche finie

La planche de dérivation finie s'est avérée assez compacte, elle s'intègre bien dans une petite planche à pain. Les schémas de la carte peuvent être trouvés ici .

Fond de panier monté sur

la carte prototype Pour programmer l'ATtiny406, un câble USB-série est connecté à la carte à l'aide des broches qui s'y trouvent.

Schéma de connexion des câbles

La partie logicielle du projet

▍pyupdi

Nous avons installé pyupdi en suivant les instructions du référentiel du projet .

Le câble USB-série a été connecté à la carte à l'aide de quatre broches UPDI. Notre convertisseur USB-série a été vu dans macOS comme un fichier /dev/tty.usbserial-FTF5HUAV.

Afin de vous assurer que le programmeur reconnaît l'ATtiny406, vous pouvez exécuter une commande similaire à la suivante en modifiant le chemin du fichier:

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

Si tout est configuré correctement, l'exécution d'une commande comme celle-ci devrait entraîner la sortie de quelque chose comme ceci:

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

Compilateur ▍C

Il s'est avéré que le compilateur avr-gcc normal qui peut être installé sur macOS à l'aide de Homebrew ne permet pas de définir ATtiny406 comme cible de compilation. Par conséquent, nous avons décidé d'installer avr-gcc fourni par Microchip. Pour télécharger le compilateur, vous devez créer un compte sur le site Web de Microchip, ce qui est un peu ennuyeux.

Téléchargement du compilateur

Après avoir téléchargé le matériel nécessaire présenté sous la forme d'une archive, nous avons décompressé cette archive dans un dossier séparé. Le chemin d'accès au répertoirebinqui sera dans ce dossier doit être ajoutéPATH. Cela facilitera le travail à l'avenir. En supposant que le compilateur est stocké dans un dossier$HOME/Src/avr8-gnu-toolchain-darwin_x86_64, vousPATHpouvez lemodifieren ajoutant la commande suivante au fichier.bash_profile:

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

Les plus récents MCU ATtiny ne sont pas pris en charge par le compilateur avr-gcc de Microchip sans configuration supplémentaire. Pour les prendre en charge, vous devez télécharger le pack d'appareils ATtiny .

Téléchargement de l'ATtiny Device Pack

En conséquence, nous avons téléchargé le packageAtmel.ATtiny_DFP.1.6.326.atpack(ce fichier peut être appelé différemment, son nom peut inclure un numéro de version différent). Bien que l'extension de fichier soit. atpack, il s'agit en fait d'une.ziparchiverégulière. Nous avons changé son extension.zipet extrait le contenu du package dans un dossier$HOME/Src/Atmel.ATtiny_DFP.1.6.326, c'est-à-dire au même endroit où se trouvaient déjà les fichiers du compilateur.

▍Écrire un programme C

Nous avons écrit le programme suivant, qui, à une fréquence de 1 Hz, fait clignoter la LED connectée à la broche B5 de notre carte 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);
    }
}

Ce code est très similaire au programme de clignotement de LED écrit pour les microcontrôleurs AVR familiers. Le premier changement notable est l'utilisation de structures pour accéder aux registres MCU. Par exemple, au lieu de faire référence à PORTB, une référence à PORTB.DIRSET.

Un autre changement est représenté par le code de réglage de fréquence (_PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, 0)). Le nouvel ATtiny406 tourne à 3,33 MHz après un redémarrage, ce qui correspond à une horloge de base de 20 MHz, qui est divisée par 6. Pour que la puce fonctionne à pleine vitesse de 20 MHz, on efface le registre CLKCTRL.MCLKCTRLB. Comme ce registre doit être protégé des modifications accidentelles, sur l'ATtiny406, une construction logicielle spéciale doit être utilisée pour le modifier. Heureusement, les macros rendent cela plus facile _PROTECTED_WRITE. Vous pouvez en savoir plus à ce sujet.ici .

Si vous comparez ce code avec celui qui est écrit pour STM32 ou SAMD21, cela s'avère beaucoup plus simple.

▍ Makefile

Ici, nous utilisons la structure de répertoires suivante:

src/Atmel.ATtiny_DFP.1.6.326/ - chemin vers Microchip Device Pack.
src/attiny406-test/- le dossier dans lequel, dans le fichier main.c, le code ci-dessus est stocké.

La compilation du code à partir du répertoire attiny406-test/peut être effectuée avec la commande suivante:

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

L'indicateur -Ovous permet d'effectuer les optimisations nécessaires pour que les appels de fonction fonctionnent correctement _delay_ms(). Il en est de même pour la variable -DF_CPUdont le contenu reflète la fréquence attendue de la puce. Le reste des paramètres contient des informations sur l'emplacement des fichiers de l'ATtiny406, que nous avons précédemment téléchargés et extraits de l'archive Device Pack.

Pour télécharger le micrologiciel sur le MCU, vous devez convertir ce que vous avez au format Intel HEX. Après cela, vous devez utiliser pyupdi. Nous avons créé une Makefilesolution simple et automatisée pour ces tâches:

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)

Pour compiler le code, exécutez simplement la commande make. Le téléchargement du code sur le microcontrôleur est effectué par la commande make flash. Soumis par nos soins Makefilepeut être, si nécessaire, révisé.

Résultat

Les nouveaux TinyAVR sont aussi faciles à programmer que les générations précédentes de MCU. La clé est de trouver les bons outils. Si vous avez des conseils pour programmer AVRTiny, partagez-les avec nous sur Twitter ou dans les commentaires ci-dessous.

Envisagez-vous d'utiliser le nouveau TinyAVR dans vos projets?

Programmation de bas niveau des microcontrôleurs tinyAVR série 0