L’ATmega328P est le microcontrôleur qui se trouve au cœur de l’Arduino Uno. Cette page présente la puce seule, en boîtier DIP-28 à broches traversantes : celle que l’on enfonce dans un support, que l’on pique sur une plaque d’essai pour la programmer, et que l’on soude sur sa propre carte une fois le projet au point.
Elle contient exactement ce que contient l’Uno — 32 Ko de mémoire programme, 23 entrées-sorties, convertisseur analogique, PWM, série, I2C, SPI — mais sans carte, sans régulateur et sans port USB. C’est la même puce ; c’est à vous de l’alimenter et de la programmer.
Pourquoi prendre la puce seule
- Pour gagner de la place — un boîtier DIP-28 de 3,5 cm sur 1,3 cm, quelques composants autour, et le montage complet entre dans une boîte de la taille d’une boîte d’allumettes.
- Pour figer un projet — on prototype sur une carte Uno, et une fois le programme au point, on soude la puce et ses quatre composants sur le circuit définitif. La carte Uno retourne au tiroir.
- Pour réparer — sur les cartes Uno dont la puce est montée sur support, une broche grillée par une surtension se remplace en dix secondes, sans jeter la carte.
- Pour comprendre — rien n’est caché derrière un port USB : on voit l’alimentation, l’horloge, le reset, et l’on sait exactement ce qui fait tourner le programme.
Caractéristiques techniques
| Référence | ATmega328P, boîtier SPDIP-28 (0,3 pouce, pas de 2,54 mm), sérigraphié ATMEGA328P |
|---|---|
| Architecture | AVR 8 bits, RISC, 131 instructions, la plupart exécutées en un cycle |
| Mémoire programme | 32 Ko de FLASH reprogrammable par ISP, lecture pendant écriture |
| Mémoire de données | 2 Ko de SRAM et 1 Ko d’EEPROM (les valeurs qui survivent à la coupure) |
| Entrées-sorties | 23 lignes réparties en trois ports : PB, PC et PD |
| Sorties PWM | 6 canaux matériels |
| Entrées analogiques | 6 canaux en boîtier DIP-28 (8 en boîtier TQFP ou QFN), convertisseur 10 bits |
| Interfaces | Port série (USART), SPI, I2C — plus un comparateur analogique |
| Compteurs | 2 compteurs 8 bits et 1 compteur 16 bits, avec modes de comparaison |
| Fonctions internes | Chien de garde (watchdog) à oscillateur indépendant, détection de chute de tension, mesure de température interne, 6 modes de veille |
| Fréquence maximale | 20 MHz sous 4,5 à 5,5 V — les cartes Arduino utilisent un quartz de 16 MHz |
| Tension d’alimentation | 1,8 à 5,5 V, mais la vitesse suit la tension : 4 MHz sous 1,8 V, 10 MHz sous 2,7 V, 20 MHz sous 4,5 V |
| Consommation | Environ 0,2 mA à 1 MHz sous 1,8 V en fonctionnement ; 0,1 µA en veille profonde |
| Horloge d’usine | Oscillateur RC interne de 8 MHz, divisé par 8, soit 1 MHz |
| Endurance | 10 000 cycles d’écriture en FLASH, 100 000 en EEPROM |
| Température de service | −40 à +85 °C (version PU, code de boîtier U) |
Le brochage du boîtier DIP-28
Vue de dessus, encoche vers le haut : la broche 1 est la première en haut à gauche, et la numérotation descend le long du côté gauche puis remonte le long du côté droit. La colonne « Arduino » donne le nom que porte la même broche sur une carte Uno.
| 1 | PC6 — RESET (remise à zéro, active à l’état bas) |
|---|---|
| 2 | PD0 — Arduino D0, réception série RXD |
| 3 | PD1 — Arduino D1, émission série TXD |
| 4 | PD2 — Arduino D2, interruption externe 0 |
| 5 | PD3 — Arduino D3, interruption 1 et PWM |
| 6 | PD4 — Arduino D4, horloge externe du compteur 0 |
| 7 | VCC — alimentation |
| 8 | GND — masse |
| 9 | PB6 — XTAL1, entrée du quartz |
| 10 | PB7 — XTAL2, sortie du quartz |
| 11 | PD5 — Arduino D5, PWM |
| 12 | PD6 — Arduino D6, PWM, entrée du comparateur |
| 13 | PD7 — Arduino D7 |
| 14 | PB0 — Arduino D8, entrée de capture |
| 15 | PB1 — Arduino D9, PWM |
| 16 | PB2 — Arduino D10, PWM et sélection SPI |
| 17 | PB3 — Arduino D11, MOSI de l’ISP |
| 18 | PB4 — Arduino D12, MISO de l’ISP |
| 19 | PB5 — Arduino D13, SCK de l’ISP et LED de la carte Uno |
| 20 | AVCC — alimentation du convertisseur analogique, à relier à l’alimentation principale |
| 21 | AREF — tension de référence du convertisseur |
| 22 | GND — masse (les deux masses, 8 et 22, doivent être reliées) |
| 23 | PC0 — Arduino A0, entrée analogique 0 |
| 24 | PC1 — Arduino A1, entrée analogique 1 |
| 25 | PC2 — Arduino A2, entrée analogique 2 |
| 26 | PC3 — Arduino A3, entrée analogique 3 |
| 27 | PC4 — Arduino A4, entrée analogique 4 et ligne SDA du bus I2C |
| 28 | PC5 — Arduino A5, entrée analogique 5 et ligne SCL du bus I2C |
Deux détails de ce tableau méritent d’être retenus : les broches du quartz (9 et 10) ne sont pas des entrées-sorties utilisables, et le boîtier DIP-28 expose une entrée analogique de moins que les boîtiers pour carte électronique — les broches qui portent ADC6 et ADC7 sur un TQFP n’existent pas ici.
Le montage minimal : ce qu’il faut ajouter autour de la puce
Une puce nue ne fait rien toute seule. Quatre connexions sont incontournables, les autres sont des précautions.
| Alimentation | Broche 7 (VCC) et broche 20 (AVCC) → +5 V. Broche 8 et broche 22 (GND) → masse. AVCC doit être reliée même si vous n’utilisez jamais l’entrée analogique. |
|---|---|
| Découplage | Un condensateur céramique de 100 nF entre le +5 V et la masse, au plus près des broches 7 et 20. Ce n’est pas une option de confort : elle évite les remises à zéro aléatoires au moment où une sortie commute. |
| Remise à zéro | Une résistance de 10 kΩ entre la broche 1 (RESET) et le +5 V. Sans elle, la puce se réinitialise au moindre parasite. Un bouton poussoir entre la broche 1 et la masse ajoute un vrai bouton de remise à zéro. |
| Horloge | Le quartz 16 MHz entre les broches 9 et 10, et un condensateur céramique de 22 pF de chaque broche vers la masse. C’est cette horloge qui donne la précision de l’Uno, et la fréquence pour laquelle les délais et le port série sont calculés. |
Sans quartz, la puce fonctionne quand même, sur son oscillateur interne de 8 MHz, réglé d’usine. C’est deux composants et un quartz en moins, et c’est très bien pour une minuterie ou un clignotant. En revanche la précision tombe à quelques pour cent, et surtout le programme doit être compilé pour 8 MHz, pas pour 16 : c’est la cause de presque toutes les surprises au premier essai, décrite plus bas.
Écrire un programme dans une puce nue
La puce n’a pas de port USB : il faut un programmateur pour poser le programme dedans. Deux chemins, tous les deux praticables à la maison.
Premier chemin : un programmateur USBasp
Le programmateur USBasp AVR se branche sur six fils, dans l’ordre du connecteur ISP : MOSI broche 17, MISO broche 18, SCK broche 19, RESET broche 1, plus VCC et GND. Dans l’IDE Arduino : choisir la carte Arduino Uno (pour que le programme soit compilé pour 16 MHz), choisir USBasp comme programmateur, puis utiliser Téléverser avec un programmateur au lieu du bouton habituel.
Second chemin : une carte Uno comme programmateur
Si vous avez déjà une carte Uno R3, elle sert de programmateur : on y téléverse le programme d’exemple ArduinoISP, on relie six fils entre les deux puces (broches 17, 18, 19, 1, plus l’alimentation et la masse), on choisit Arduino as ISP comme programmateur, et l’on téléverse la puce cible. Deux précautions : la carte qui programme garde son propre programme, et il faut retirer la puce cible du montage pendant l’opération si elle pilote autre chose.
Avant tout : lire l’horloge de la puce
Une puce neuve sort d’usine avec son oscillateur interne divisé par huit, donc à 1 MHz. Un programme compilé pour 16 MHz y tournera seize fois trop lentement : le clignotant que vous attendez au rythme d’une seconde clignotera à seize secondes, et le port série parlera à une vitesse incohérente. Ce n’est pas un bug, c’est un décalage d’horloge.
Pour savoir où vous en êtes, lisez le fusible d’horloge avec le programmeur branché : avrdude -c usbasp -p m328p -U lfuse:r:-:h. Deux réponses à connaître : 0x62 correspond à l’oscillateur interne d’usine (1 MHz), et une valeur de l’ordre de 0xFF correspond à un quartz externe en configuration Arduino Uno (16 MHz). Dans le premier cas, il faut écrire les fusibles et le programme pour 16 MHz — l’IDE le fait d’un coup avec Graver la séquence d’initialisation, carte Arduino Uno sélectionnée — ou compiler votre programme pour 8 MHz interne si vous avez choisi de vous passer de quartz.
Mini-projet : faire clignoter une LED depuis la puce seule
Le montage de la photo ci-dessous tient sur un tiers de plaque à essai, et c’est le même clignotant que le premier exemple de l’IDE Arduino — la broche 19 du boîtier est exactement la broche D13, celle de la LED de l’Uno.
Ce qu’il faut
| La puce | Ce microcontrôleur ATmega328P en boîtier DIP-28 |
|---|---|
| L’horloge | Quartz 16 MHz et deux condensateurs céramiques de 22 pF |
| Le reset | Résistances 1/4 w 10 kΩ — une seule suffit pour le montage |
| Le voyant | LED 5mm Rouge |
| La protection de la LED | Résistances 1/4 w 220 ohm |
| Le support | Plaque d’essai 830 points |
| Les liaisons | 10 × fil mâle-mâle 10 cm |
| Le programmateur | Programmateur USBasp AVR, ou une carte Uno chargée d’ArduinoISP |
Le câblage
Broche 7 VCC | → rail + de la plaque |
|---|---|
Broche 20 AVCC | → rail + de la plaque |
Broches 8 et 22 GND | → rail − de la plaque |
Broche 1 RESET | → rail + par la résistance de 10 kΩ |
Broche 9 XTAL1 | → une patte du quartz, et un condensateur de 22 pF vers la masse |
Broche 10 XTAL2 | → l’autre patte du quartz, et un condensateur de 22 pF vers la masse |
| Broche 19 (PB5) | → LED, patte longue côté puce, en passant par la résistance de 220 Ω |
| LED, patte courte | → rail − de la plaque |
| Programmateur | → MOSI 17, MISO 18, SCK 19, RESET 1, VCC et GND |
Le piège du premier montage : le quartz est un composant symétrique, mais les deux condensateurs de 22 pF ne le sont pas moins — chacun va d’une patte du quartz vers la masse, jamais entre les deux pattes du quartz. Un condensateur placé entre les broches 9 et 10 empêche l’oscillateur de démarrer, et la puce reste muette sans rien dire.
Le programme
À copier dans l’IDE Arduino, carte Arduino Uno sélectionnée, puis à téléverser avec le programmateur :
/*
* Clignotant minimal - ATmega328P en boitier DIP-28
* Horloge : quartz externe 16 MHz
* Montage : LED et sa resistance de 220 ohms sur la broche 19 du boitier
*
* Composants, brochage et fiche complete : www.marocproduits.com
*/
const byte PIN_LED = 13; // nom Arduino de la broche 19 du boitier (PB5)
void setup() {
pinMode(PIN_LED, OUTPUT);
}
void loop() {
digitalWrite(PIN_LED, HIGH); // la LED s'allume
delay(500);
digitalWrite(PIN_LED, LOW); // la LED s'eteint
delay(500);
}Ce que fait le programme
13est le nom Arduino de la broche 19 du boîtier : la même convention que sur une carte Uno, ce qui veut dire que tout croquis écrit pour l’Uno fonctionne ici sans réécriture.pinMode(PIN_LED, OUTPUT)configure la broche en sortie. Sur une puce neuve, une broche non configurée est en entrée haute impédance : elle ne peut rien allumer.- Les deux
delay(500)donnent une seconde de cycle complet. Si votre LED clignote beaucoup plus lentement, l’horloge n’est pas à 16 MHz : relisez le paragraphe sur les fusibles.
Pour aller plus loin
- Voir ce qui se passe dans le port série — ajoutez
Serial.begin(9600);danssetup(), reliez broche 3 (TXD) vers la broche de réception d’un convertisseur USB vers TTL, et la console de l’IDE affiche vos messages. Le convertisseur sert aussi à reposer un programme sans programmateur, si vous avez gravé le bootloader. - Un vrai bouton — un mini bouton poussoir entre la broche 1 et la masse remplace le débranchement de l’alimentation pour redémarrer la puce.
- Un compteur affiché — un afficheur LCD 16×02 I2C se branche sur les broches 27 et 28 (
SDAetSCL) et n’a besoin que de quatre fils. - Le même projet, alimenté par piles — en utilisant l’oscillateur interne à 8 MHz et les modes de veille, la consommation descend sous le milliampère.
Variantes
Avec l’oscillateur interne, sans quartz
Vous gagnez le quartz et les deux condensateurs, et deux broches libres. Le prix à payer : une horloge à quelques pour cent, un port série utilisable seulement sur de courtes distances, et un projet à compiler pour 8 MHz. C’est le bon choix pour un montage autonome sur piles qui dort entre deux réveils, pas pour un appareil qui doit mesurer le temps.
Sous 3,3 V
La puce accepte de 1,8 à 5,5 V, mais la fréquence maximale suit la tension : 10 MHz sous 3,3 V. Pour un montage en 3,3 V, on utilise donc un quartz de 8 MHz et l’on compile pour cette fréquence — le microcontrôleur reste parfaitement fiable, il travaille simplement plus lentement.
Si vous préférez une carte prête à l’emploi
Le Pro Mini Atmega328 5v 16MHz embarque cette même puce, son quartz, son régulateur et son connecteur de programmation : vous retrouvez le même programme, sans aucun câblage d’horloge ni de reset.
Questions fréquentes
La puce est-elle livrée avec le bootloader Arduino ?
La puce est le composant d’origine du fabricant : elle sort d’usine avec son oscillateur interne et sans bootloader. Selon l’arrivage, votre exemplaire peut avoir été préparé autrement, et le contrôle prend dix secondes — c’est la lecture du fusible d’horloge décrite plus haut. Dans tous les cas, cela ne vous empêche rien : téléversez directement votre programme avec le programmateur, ou gravez d’abord la séquence d’initialisation pour vous passer ensuite de lui.
Puis-je m’en servir pour remplacer la puce d’une carte Uno ?
Oui, sur les cartes dont la puce se trouve sur un support — c’est le cas de la plupart des modèles à broches traversantes, et c’est justement l’intérêt du boîtier DIP. Si la puce est soudée en surface, le remplacement demande une station à air chaud. Dans les deux cas, si vous remplacez la puce par une neuve, il faut graver la séquence d’initialisation avant que la carte ne redevienne un Uno.
Pourquoi ma puce neuve clignote-t-elle seize fois trop lentement ?
Parce qu’elle tourne sur son oscillateur interne divisé par huit, donc à 1 MHz, alors que votre programme a été compilé pour 16 MHz. Tous les délais sont multipliés par seize et le port série parle à la mauvaise vitesse. Écrivez les fusibles pour le quartz externe, puis téléversez de nouveau — dans cet ordre.
Combien de courant peut-on tirer d’une broche ?
20 mA en usage normal, 40 mA en maximum absolu et sans garantie de durée, avec un plafond de 200 mA pour l’ensemble des broches. Au-delà, il faut un transistor : un relais, un moteur ou une bande de LED se commandent par un module relais ou un transistor, jamais directement.
Faut-il un support ?
Sur une plaque d’essai, la puce se pique telle quelle et tient très bien. Sur un circuit imprimé définitif, un support DIP-28 est une bonne habitude : il évite de dessouder vingt-huit broches le jour où le programme doit être corrigé, et il protège la puce de la chaleur du fer.
Quelle différence avec un ATmega168 ou un ATmega8 ?
Seules les mémoires changent : 16 Ko de FLASH et 1 Ko de SRAM pour le 168, 32 Ko et 2 Ko pour le 328. Le brochage et les programmes sont identiques ; le « P » final indique la génération à faible consommation. Autrement dit, un programme écrit pour un 168 tient dans un 328, l’inverse n’est pas toujours vrai.
À combiner avec
Pour démarrer sans rien chercher, le KIT Starter réunit une carte Uno R3, une plaque d’essai, des fils, des résistances et des LED : vous y programmez d’abord la puce, puis vous la reportez sur votre propre montage. Le quartz 16 MHz est la pièce à avoir en double, et le programmateur USBasp reste la façon la plus directe d’écrire dans une puce nue.
