🧊 Atmel-ICE & Microchip Studio

Les outils professionnels du monde AVR

Si le PICkit 3 + MPLAB X forment l'écosystème officiel des PIC, le duo Atmel-ICE + Microchip Studio est l'équivalent pour le monde AVR (ATmega, ATtiny, AT90, XMEGA, SAM). Ces outils offrent des capacités de débogage avancées que les alternatives gratuites (USBasp, Arduino as ISP) ne possèdent pas.

Ce guide couvre l'ensemble de la chaîne de développement professionnelle pour AVR :

• Atmel-ICE — Le programmateur/débogueur matériel officiel de Microchip
• Microchip Studio (ex Atmel Studio 7) — L'IDE de développement complet basé sur Visual Studio
• AVR-GCC — Le compilateur C/C++ open-source intégré dans l'IDE
• Alternatives — USBasp, AVRISP mkII, MPLAB SNAP et Arduino as ISP

🧊 L'Atmel-ICE — Programmateur et débogueur

Qu'est-ce que l'Atmel-ICE ?

L'Atmel-ICE est le programmateur/débogueur officiel de Microchip pour toutes les familles AVR et SAM. C'est l'outil de référence pour le développement professionnel. Il supporte trois interfaces de programmation/débogage :

• ISP (In-System Programming) — Programmation série via SPI. Compatible avec tous les AVR (ATmega, ATtiny). 6 broches.
• JTAG — Interface de débogage avancée. Disponible sur les ATmega avec 44 broches ou plus (ATmega1284, ATmega2560, XMEGA). 10 broches.
• debugWIRE (dW) — Interface de débogage à un seul fil, via la broche RESET. Disponible sur les ATmega à faible nombre de broches (ATmega328P, ATmega168, ATtiny). Moins de fonctionnalités que JTAG mais idéal pour les chips compacts.

Caractéristiques techniques

🔌 Connecteur ISP — Brochage 6 broches

Le connecteur ISP standard utilise un header 2×3 broches au pas de 2.54 mm. C'est le connecteur le plus utilisé pour programmer les AVR :

Câblage sur breadboard

Si vous n'avez pas de connecteur ISP 6 broches sur votre breadboard, vous pouvez câbler les 6 fils individuellement entre l'Atmel-ICE et les broches correspondantes de l'ATmega328P ou de l'ATtiny85. Utilisez des fils dupont femelle-mâle.

📥 Installation de Microchip Studio (ex Atmel Studio)

Présentation

Microchip Studio (anciennement Atmel Studio 7) est l'IDE officiel et gratuit pour le développement AVR et SAM. Il est basé sur Microsoft Visual Studio Shell, ce qui lui confère une interface riche avec autocomplétion IntelliSense, navigation dans le code, refactoring et un débogueur visuel puissant.

L'IDE intègre directement le compilateur AVR-GCC (pour C/C++) et l'assembleur AVR-AS, ainsi que le support de tous les programmateurs Microchip (Atmel-ICE, AVRISP mkII, MPLAB SNAP) et de nombreux programmateurs tiers.

Étape 1 : Téléchargement

Rendez-vous sur microchip.com → Microchip Studio et téléchargez l'installateur (~850 Mo). Un compte Microchip gratuit peut être requis.

Étape 2 : Installation

1. Lancez l'installateur en tant qu'administrateur.
2. Sélectionnez les composants à installer :
   • ✅ AVR/SAM 8-bit MCU — Obligatoire pour ATmega et ATtiny
   • ✅ AVR-GCC Toolchain — Le compilateur C/C++
   • ☑️ ARM/SAM 32-bit MCU — Optionnel, pour les SAM (Cortex-M)
3. L'installation prend 10 à 20 minutes selon votre PC (le téléchargement des toolchains est long).
4. Redémarrez Windows si demandé (nécessaire pour les pilotes USB de l'Atmel-ICE).

Étape 3 : Vérification

1. Lancez Microchip Studio.
2. Branchez votre Atmel-ICE en USB. La LED verte doit s'allumer.
3. Allez dans Tools → Device Programming (ou Ctrl+Shift+P).
4. Dans le panneau, sélectionnez votre outil (Atmel-ICE), l'interface (ISP) et le device (ATmega328P).
5. Cliquez « Apply » puis « Read → Device Signature ».
6. Si la signature est lue correctement (0x1E9514 pour l'ATmega328P), tout fonctionne.

🧭 L'interface de Microchip Studio

L'interface est similaire à Visual Studio et se compose de :

• Solution Explorer (droite) — Arborescence du projet (fichiers sources, headers, bibliothèques).
• Éditeur de code (centre) — Avec coloration syntaxique, IntelliSense (autocomplétion), navigation rapide (F12 = aller à la définition).
• Output Window (bas) — Messages de compilation, erreurs, warnings, infos de programmation.
• Error List (bas) — Liste triée des erreurs et warnings cliquables (double-clic = aller à la ligne).
• Barre d'outils — Boutons Build, Debug, Device Programming, sélection du projet actif.
• Debug Windows (pendant le débogage) — Locals, Watch, Registers, Memory, I/O View, Breakpoints, Call Stack.

I/O View — La killer feature

La fenêtre I/O View (View → I/O View pendant le débogage) affiche tous les registres du microcontrôleur en temps réel avec leurs bits nommés. Vous pouvez voir et modifier PORTB, DDRB, ADMUX, TCCR1A etc. pendant que le programme est en pause. C'est un outil de débogage incroyablement puissant qui n'a pas d'équivalent dans l'IDE Arduino.

🆕 Créer un projet AVR-GCC

1. Ouvrez Microchip Studio.
2. Allez dans File → New → Project (ou Ctrl+Shift+N).
3. Sélectionnez « GCC C Executable Project ».
4. Donnez un nom au projet (ex : LED_Blink_ATmega328P) et choisissez un dossier.
5. Cliquez OK.
6. Dans la fenêtre de sélection du device, tapez ATmega328P dans la recherche et sélectionnez-le.
7. Cliquez OK. Le projet est créé avec un fichier main.c pré-rempli.

Premier programme

Remplacez le contenu de main.c par :

#define F_CPU 16000000UL  // 16 MHz (Arduino Uno) ou 1 MHz (interne)

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

int main(void) {
    DDRB |= (1 << PB5);  // PB5 (D13) en sortie

    while (1) {
        PORTB ^= (1 << PB5);  // Toggle LED
        _delay_ms(500);
    }
}

Configurer F_CPU

La macro F_CPU doit correspondre à la fréquence réelle de votre oscillateur. Si vous programmez un ATmega328P standalone avec l'oscillateur interne (pas un Arduino), la fréquence par défaut est 1 MHz (8 MHz / diviseur 8). Sur un Arduino Uno avec quartz 16 MHz, c'est 16 MHz.

Vous pouvez aussi définir F_CPU dans les propriétés du projet : Project → Properties → Toolchain → AVR/GNU C Compiler → Symbols → ajoutez F_CPU=16000000UL.

🔨 Compiler et programmer

Compilation

1. Cliquez sur Build → Build Solution (ou F7).
2. Vérifiez la console Output. Vous devez voir :

Build succeeded.
========== Build: 1 succeeded or up-to-date, 0 failed ==========

Program Memory Usage: 178 bytes   0.5% Full
Data Memory Usage:      0 bytes   0.0% Full

Notez l'utilisation mémoire ultra-compacte : 178 octets pour un Blink LED, contre ~930 octets avec le framework Arduino.

Programmation via Atmel-ICE

1. Allez dans Tools → Device Programming (Ctrl+Shift+P).
2. Sélectionnez : Tool = Atmel-ICE, Device = ATmega328P, Interface = ISP.
3. Cliquez Apply.
4. Cliquez Read dans la section « Device Signature » pour vérifier la communication.
5. Dans l'onglet Memories, le fichier .elf de votre projet devrait être sélectionné automatiquement.
6. Cliquez Program.
7. Le message « Erasing device... OK / Programming Flash... OK / Verifying Flash... OK » confirme le succès.

🐛 Le débogueur — La vraie puissance de l'Atmel-ICE

Le débogage est la raison principale d'investir dans un Atmel-ICE plutôt qu'un simple USBasp. Le débogueur permet d'exécuter le code pas à pas sur le vrai microcontrôleur, d'inspecter les variables et les registres en temps réel, et de placer des points d'arrêt.

Interfaces de débogage

Déboguer avec debugWIRE (ATmega328P)

1. Dans Project → Properties → Tool, sélectionnez l'Atmel-ICE et l'interface debugWIRE.
2. Placez un breakpoint en cliquant dans la marge gauche de l'éditeur (point rouge).
3. Lancez le débogage avec Debug → Start Debugging and Break (Alt+F5).
4. L'IDE peut demander d'activer le fuse DWEN (debugWIRE Enable). Acceptez — c'est automatique et réversible.
5. Le programme s'exécute sur le microcontrôleur et s'arrête au premier breakpoint.

Commandes de débogage

Fenêtres de débogage utiles

• Locals — Affiche automatiquement toutes les variables locales de la fonction courante avec leur valeur.
• Watch — Ajoutez manuellement des variables ou des expressions à surveiller (ex : PORTB, compteur, ADC).
• I/O View — Affiche TOUS les registres périphériques du MCU (PORTB, DDRB, ADMUX, TCCR1A…) avec chaque bit nommé. Vous pouvez même modifier les bits en cliquant dessus.
• Memory — Affiche le contenu brut de la Flash, SRAM, EEPROM en hexadécimal.
• Processor — Affiche le Program Counter, Stack Pointer, Status Register (SREG) et les 32 registres de travail R0–R31.

⚙️ Configuration des fuses

Les fuses sont l'équivalent AVR des #pragma config des PIC. Ce sont des bits de configuration non volatiles qui définissent le comportement fondamental du microcontrôleur : source d'horloge, diviseur, Brown-Out Detect, bootloader, etc.

Lire et écrire les fuses dans Microchip Studio

1. Allez dans Tools → Device Programming.
2. Sélectionnez votre outil et device, cliquez Apply.
3. Cliquez sur l'onglet Fuses.
4. Cliquez Read pour lire les fuses actuels.
5. Modifiez les valeurs dans l'interface graphique (menus déroulants).
6. Cliquez Program pour écrire les nouveaux fuses.

Fuses courants ATmega328P

🔄 Alternatives à l'Atmel-ICE

Notre recommandation

• Débutant / budget serré → USBasp (~3 €) pour la programmation ISP, ou Arduino as ISP si vous avez déjà un Arduino. Suffisant pour tous nos tutoriels.
• Apprentissage sérieux → Clone Atmel-ICE (~30 €) pour avoir le débogage debugWIRE. L'investissement vaut le coup pour comprendre le code en profondeur.
• Professionnel / universitaire → Atmel-ICE original (~100 €) pour la fiabilité et le support complet de tous les protocoles.
• Multi-plateforme PIC + AVR → MPLAB SNAP (~15 €) qui programme les deux familles avec MPLAB X.

💻 Alternative : VS Code + PlatformIO

Si vous êtes sur macOS ou Linux, ou si vous préférez un IDE plus léger et moderne, VS Code + PlatformIO est une excellente alternative à Microchip Studio :

• Multi-plateforme — Fonctionne sur Windows, macOS et Linux.
• Multi-architecture — Supporte AVR, Arduino, ESP32, STM32, PIC32 dans le même IDE.
• Autocomplétion avancée — IntelliSense C/C++ avec navigation rapide.
• Gestion de bibliothèques — Recherche et installation de bibliothèques en un clic.
• Compilation et téléversement intégrés — Supporte USBasp, Atmel-ICE, Arduino as ISP.
• Terminal intégré — Accès direct à avrdude pour les opérations avancées.

Installation rapide

1. Installez VS Code.
2. Installez l'extension PlatformIO IDE depuis le marketplace.
3. Créez un nouveau projet : PlatformIO → New Project → Board = « ATmega328P » → Framework = « Arduino » (ou aucun pour bare metal).
4. Codez dans src/main.c, compilez avec Ctrl+Alt+B, téléversez avec Ctrl+Alt+U.

📌 Comparaison des écosystèmes : PIC vs AVR