🧠 Introduction à l'ATmega328P

Qu'est-ce que l'ATmega328P ?

L'ATmega328P est un microcontrôleur 8 bits de la famille AVR, conçu par Atmel (racheté par Microchip Technology en 2016). C'est le microcontrôleur qui équipe l'Arduino Uno et l'Arduino Nano, ce qui en fait le MCU le plus utilisé au monde pour le prototypage.

Cependant, l'ATmega328P est bien plus qu'un « chip Arduino ». C'est un microcontrôleur complet et puissant que l'on peut programmer sans la couche d'abstraction Arduino, en accédant directement aux registres avec AVR-GCC (le compilateur C officiel pour AVR). Cette approche « bare metal » offre un contrôle total sur le matériel, des performances optimales et une compréhension profonde du fonctionnement interne.

📊 Caractéristiques techniques

Caractéristique	Valeur
Architecture	AVR 8 bits, Harvard modifiée, RISC (131 instructions)
Fréquence max	20 MHz (16 MHz sur Arduino Uno)
Mémoire Flash	32 Ko (programme)
SRAM	2 Ko (variables, pile)
EEPROM	1 Ko (stockage persistant)
GPIO	23 broches (3 ports : B, C, D)
ADC	6 canaux, 10 bits
Timers	Timer0 (8 bits), Timer1 (16 bits), Timer2 (8 bits)
PWM	6 canaux
Communication	USART, SPI, I2C (TWI)
Interruptions	26 vecteurs (INT0, INT1, PCINT, Timer, ADC, USART…)
Tension de fonctionnement	1.8V – 5.5V
Boîtier	DIP-28, TQFP-32, QFN-32

🏗️ Architecture AVR

L'ATmega328P utilise une architecture Harvard modifiée avec des bus séparés pour les instructions (Flash) et les données (SRAM). Cela permet au processeur de lire une instruction et d'accéder aux données simultanément, améliorant les performances.

Les 3 espaces mémoire

• Flash (32 Ko) — Stocke votre programme. Non volatile (persiste sans alimentation). Supporte ~10 000 cycles d'écriture.
• SRAM (2 Ko) — Mémoire de travail volatile. Contient les variables, la pile (stack) et le tas (heap). Se vide à chaque redémarrage.
• EEPROM (1 Ko) — Mémoire non volatile pour le stockage persistant de paramètres (calibration, configuration). Supporte ~100 000 cycles d'écriture.

Les 32 registres de travail

Le cœur AVR dispose de 32 registres 8 bits (R0 à R31) qui servent à effectuer les opérations arithmétiques et logiques. Les registres R26-R31 peuvent être utilisés par paires comme pointeurs 16 bits (X, Y, Z) pour l'adressage indirect. La plupart des instructions s'exécutent en un seul cycle d'horloge, ce qui rend l'AVR très efficace.

📌 Les ports GPIO de l'ATmega328P

L'ATmega328P organise ses 23 broches GPIO en 3 ports :

Port	Broches	Arduino Uno	Fonctions spéciales
PORTB	PB0–PB5 (6 bits utiles)	D8–D13	SPI (PB2-PB5), Quartz (PB6-PB7), PWM (PB1,PB2,PB3)
PORTC	PC0–PC5 (6 bits utiles)	A0–A5	ADC (PC0-PC5), I2C (PC4=SDA, PC5=SCL), Reset (PC6)
PORTD	PD0–PD7 (8 bits)	D0–D7	USART (PD0=RX, PD1=TX), INT0/INT1 (PD2,PD3), PWM (PD3,PD5,PD6)

Chaque port est contrôlé par 3 registres :

• DDRx (Data Direction Register) — Définit la direction : 1 = sortie, 0 = entrée.
• PORTx — En sortie : écrit la valeur (HIGH/LOW). En entrée : active/désactive la résistance pull-up interne.
• PINx — Lit l'état logique actuel de la broche (lecture seule).

🛠️ Outils de développement

• AVR-GCC — Compilateur C/C++ open-source pour AVR. Inclus dans l'Arduino IDE, mais utilisable indépendamment en ligne de commande.
• Microchip Studio (ex Atmel Studio) — IDE complet et gratuit pour AVR et SAM. Intègre AVR-GCC, un simulateur et le support des programmateurs Atmel-ICE.
• VS Code + PlatformIO — Alternative moderne avec autocomplétion, débogage et support de multiples plateformes (AVR, ESP32, STM32…).
• avrdude — Utilitaire en ligne de commande pour programmer les AVR. Utilisé en arrière-plan par l'IDE Arduino.

Programmateurs compatibles

• USBasp — Programmateur ISP très abordable (~3 €). Le plus populaire pour la programmation AVR sans Arduino.
• Atmel-ICE — Programmateur/débogueur officiel Microchip. Support JTAG et debugWIRE.
• Arduino as ISP — Utilisez un Arduino Uno comme programmateur ISP pour d'autres AVR (y compris ATtiny).

💻 Premier programme « bare metal »

Voici l'équivalent du Blink Arduino, mais en accès direct aux registres :

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

int main(void) {
    // PB5 = broche 13 Arduino = LED intégrée
    DDRB |= (1 << PB5);     // PB5 en sortie

    while (1) {
        PORTB |= (1 << PB5);   // PB5 = HIGH (LED ON)
        _delay_ms(500);

        PORTB &= ~(1 << PB5);  // PB5 = LOW (LED OFF)
        _delay_ms(500);
    }

    return 0;
}

Ce code fait exactement la même chose que le Blink Arduino, mais en ~178 octets de Flash contre ~900 octets pour la version Arduino. La différence : pas de bootloader, pas de framework, juste du pur C et des registres.

🔄 ATmega328P vs Arduino : pourquoi programmer « sans Arduino » ?

• Performance — L'accès direct aux registres est beaucoup plus rapide. PORTB |= (1 << PB5) s'exécute en 2 cycles d'horloge (~125 ns à 16 MHz) contre ~60 cycles pour digitalWrite().
• Taille du code — Un programme bare metal est 3 à 10 fois plus compact qu'un sketch Arduino équivalent. Crucial pour les ATtiny avec seulement 1 Ko de Flash.
• Compréhension — Programmer au niveau registre vous donne une compréhension profonde du fonctionnement du matériel, indispensable pour devenir ingénieur embarqué.
• Contrôle total — Vous maîtrisez chaque bit de chaque registre. Pas de surprises liées au framework Arduino (timers réservés, interruptions cachées).
• Portabilité — Les concepts AVR s'appliquent à toute la famille (ATmega, ATtiny, AT90), alors que le code Arduino ne fonctionne que sur les cartes supportées.