ATmega328P Essentiels : Commencer sans Arduino

J'utilise la carte Arduino Uno depuis un certain temps, y compris comme exemples pour bon nombre de mes articles. Je me suis toujours demandé ce qu'il faudrait pour faire fonctionner complètement par lui-même le ATmega328P (le composant original utilisé sur les anciennes cartes Uno). Avec Arduino rendant cela si accessible via son bootloader, son logiciel GUI agréable et son abstraction en C++, on pourrait se demander pourquoi diable je voudrais même tenter cela. Parfois, pour apprécier ce que les autres ont fait, il est important d'essayer de le faire soi-même. Ce projet a vraiment démontré combien de travail les gens d'Arduino ont mis dans cela et ont changé le monde avec ce petit produit sympathique.

Dans cet article, nous allons parcourir la mise en route du composant complètement par lui-même en utilisant seulement une source d'alimentation externe et un programmeur Atmel-ICE. Nous démontrerons comment communiquer avec le composant via l'interface série embarquée et aussi faire clignoter une ou deux LED.

Configuration de l'environnement

Il existe quelques façons de configurer un ATmega328P. Une de ces façons, intentionnellement non couverte comme vous pouvez le deviner par le titre, consiste à insérer votre puce ATmega328P dans un Arduino Uno, la programmer, puis la transférer sur une plaque d'essai. Basé sur les retours sur les forums, certaines personnes veulent sauter le processus Arduino et utiliser une approche plus traditionnelle avec des programmeurs tels que l'Atmel-ICE de Microchip. La manière la plus directe de commencer avec un microprocesseur Microchip (anciennement Atmel) est d'installer Microchip Studio. Au moment de la rédaction de cet article, la suite complète de Microchip Studio est uniquement prise en charge sous Windows. Comme j'aime avoir tous mes environnements de build fonctionnant en CI (Intégration Continue), j'ai opté pour une approche alternative.

La GNU Compiler Collection (GCC) est l'un des compilateurs les plus populaires pour le langage C. Il compile certaines plateformes et architectures mais pas pour la famille de puces AVR (ATmega). Il existe, cependant, un ensemble de compilateurs pour les AVR et autres familles Microchip hébergés sur leur site web. Heureusement, des personnes bien intentionnées ont même empaqueté ces compilateurs dans de jolis paquets Debian qui peuvent facilement être installés sous Debian ou Ubuntu comme ceci :

$ apt-get install gcc-avr binutils-avr avr-libc avrdude

Avec ces outils installés, nous sommes maintenant capables de compiler et de programmer le ATmega328P avec seulement un programmeur Atmel-ICE et une alimentation externe (réglée sur 5V). Nous utiliserons la version AVR de GCC pour compiler le code et AVRDUDE pour flasher la puce ATmega328P.

Le Projet

Pour ce projet, mon objectif était de démontrer quelques capacités basiques, mais fonctionnelles, du ATmega328P. Une simple LED externe clignotante et quelques commandes série aller-retour étaient tout ce dont j'avais besoin pour prouver que ce composant pouvait se tenir seul. Dans le répertoire du projet j'ai créé quelques dossiers en plus du code source (nommé "src") qui assistent dans le développement de ce projet.

Un composant important du développement logiciel (même pour les logiciels destinés à l'hardware) est le test unitaire. Le test unitaire valide que les fonctions ou morceaux du système plus large fonctionnent comme prévu. Si quelqu'un vient modifier un élément de cette fonctionnalité, le test unitaire empêchera les régressions (c'est-à-dire que vous avez involontairement cassé quelque chose d'autre en introduisant une nouvelle fonctionnalité). Dans cet exemple, j'ai écrit un test unitaire de base qui simule le matériel et exécute le schéma d'initialisation de la bibliothèque de communication série (USART).

En plus des tests unitaires (situés dans le dossier “tests”), il y a aussi un dossier appelé “hil” qui signifie Hardware in the Loop. Ce dossier contient les scripts nécessaires pour exécuter des tests avec du matériel réel dans la boucle (comme discuté dans plusieurs de mes articles précédents). Cela garantit que mon code est fonctionnel non seulement dans le monde virtuel (en utilisant des simulations) mais aussi dans le monde réel en exécutant des tests sur du matériel réel.

Consulter le README.md vous fournira un schéma de brochage pour connecter le programmeur Atmel-ICE au chip ATmega328P :

Figure 1 : Brochage Atmel ICE

Ajouter quelques LED, connecter le port de communication série à un Raspberry Pi, et se brancher sur la ligne +5V du Raspberry Pi et vous avez maintenant un ensemble complet prêt à l'emploi :

Figure 2 : ATmega328P utilisant une carte d'extension avec le Raspberry Pi et le programmeur Atmel-ICE

Tests, Compilation, et Plus de Tests

Lorsque vous développez de nouvelles fonctionnalités, utilisez le Makefile pour exécuter les tests unitaires et compiler le code. Après avoir validé que le code souhaité fait ce qu'il est censé faire (via la validation des tests unitaires), construisez le binaire, flashez-le sur l'appareil (également via le Makefile), et exécutez des tests Hardware in the Loop (HIL) en utilisant le port de communication série du Raspberry Pi.

Une des pièces les plus importantes est de flasher correctement les bits de fusible pour activer l'horloge interne de 8 MHz. Cela est documenté dans le README mais également ajouté à la commande de flashage dans le Makefile :

avrdude -c atmelice_isp -p m328p -B 32 -U lfuse:w:0xe2:m

Après cela, vous devriez être capable d'utiliser l'interface série du chip en supposant que l'horloge embarquée fonctionne à 8 MHz (comme défini en haut de main.c). À partir de là, vous devriez être capable d'ajouter plus de fonctionnalités telles que le support pour des commandes série supplémentaires, des interfaces pour des composants et capteurs externes, et tout ce que vous pouvez imaginer avec ce petit microcontrôleur amusant.

Conclusion

Dans cet article, vous avez appris comment démarrer avec le chip ATmega328P sans aucun circuit externe comme on le voit couramment avec les Arduino Unos originaux et les cartes d'évaluation Microchip. Vous connaissez maintenant le concept de tests unitaires, de constructions binaires, de programmation du chip et de réalisation de tests en boucle fermée. De plus, un détail important, souvent négligé, concernant la programmation des bits de fusible pour régler l'horloge interne à 8 MHz a été abordé. À ce stade, vous devriez être capable d'ajouter plus de fonctionnalités avec des tests unitaires et en boucle fermée supplémentaires et de tout exécuter avec juste un programmeur Atmel-ICE et une alimentation externe de 5V. Pour simplifier, l'utilisation d'un Raspberry Pi pour sa source d'alimentation et ses capacités de communication série serait le moyen le plus facile de contrôler le processus de bout en bout.

Le code source du projet peut être trouvé ici :https://gitlab.com/embedded-designs/atmega328p-serial-led-control.