Arduino Pro Mini : programmation, brochage et basse consommation
Arduino Pro Mini : 3,3 V ou 5 V, programmation par USB-TTL, brochage, veille en µA avec LowPower, capteur nRF24 sur piles et comparaison avec le Nano.
L'Arduino Pro Mini est une carte Arduino dotée du même processeur ATmega328P que l'Arduino Uno, mais elle ne mesure que 18 × 33 mm et n'a pas de prise USB. Elle existe en deux versions, 3,3 V / 8 MHz et 5 V / 16 MHz, et se programme avec un adaptateur USB-TTL. Sa petite taille, son prix bas et un courant de veille qui descend à quelques microampères une fois bien préparée en font la carte préférée des capteurs sans fil qui tournent des mois, voire des années sur piles, des projets portables et des montages intégrés à demeure dans un boîtier.
Dans ce guide, tu apprendras la différence entre les deux versions et comment reconnaître la tienne, le brochage, les broches d'alimentation RAW et VCC, ainsi que la programmation avec un adaptateur USB-TTL et la réinitialisation automatique par DTR. Ensuite, tu endormiras la carte avec la bibliothèque LowPower, tu feras passer la consommation des milliampères aux microampères en retirant la LED d'alimentation et le régulateur, et tu construiras un nœud capteur sur piles qui envoie la température mesurée avec un nRF24L01. La dernière partie compare le Pro Mini à l'Arduino Nano pour savoir lequel choisir et quand.

Qu'est-ce que l'Arduino Pro Mini ? Versions 3,3 V et 5 V
Le Pro Mini a été conçu à l'origine par SparkFun ; la plupart des cartes vendues aujourd'hui sont des clones de ce même design ouvert. La carte porte l'ATmega328P, cœur de l'Uno, un quartz, un petit régulateur de tension, deux LED et un bouton reset ; il n'y a ni puce USB, ni prise USB, ni gros étage d'alimentation. Presque tout le code écrit pour l'Uno fonctionne sans modification. Le vrai choix porte sur la tension de fonctionnement. L'ATmega328P a besoin d'environ 3,8 V ou plus pour tourner de façon fiable à 16 MHz ; la version 3,3 V est donc équipée d'un quartz de 8 MHz et tourne à mi-vitesse. En échange, elle dialogue sans convertisseur de niveau avec les modules 3,3 V comme le nRF24L01, le BME280 ou une carte SD, et peut être alimentée directement par une batterie.
| Caractéristique | Version 3,3 V / 8 MHz | Version 5 V / 16 MHz |
|---|---|---|
| Processeur | ATmega328P | ATmega328P |
| Fréquence d'horloge | 8 MHz | 16 MHz |
| Niveau logique et VCC | 3,3 V | 5 V |
| Entrée RAW | 3,35–12 V | 5–12 V |
| Mémoire programme | 32 Ko (30 Ko utilisables, 2 Ko de bootloader) | 32 Ko (30 Ko utilisables) |
| SRAM / EEPROM | 2 Ko / 1 Ko | 2 Ko / 1 Ko |
| Broches numériques / PWM | 14 / 6 | 14 / 6 |
| Entrées analogiques | 8 (A0–A7) | 8 (A0–A7) |
| Vitesse de téléversement | 57600 bauds | 57600 bauds |
| Marquage du quartz | 8.000 | 16.000 |
| Idéale pour | Capteurs sur piles, modules 3,3 V | Capteurs 5 V, relais et LED, tâches qui demandent de la vitesse |
Brochage de l'Arduino Pro Mini
Le Pro Mini a 12 broches sur chaque grand côté et le connecteur de programmation à six broches sur le petit côté. Les numéros de broches sont exactement ceux de l'Uno : tu peux donc tester un projet sur l'Uno et le passer au Pro Mini avec le même code. La seule différence à surveiller est que A4, A5, A6 et A7 ne sont pas sur le bord mais dans des trous séparés, à l'intérieur de la carte. Pour voir rapidement ce qui se trouve sur chaque broche, consulte aussi l'outil de brochage.
| Broche | Rôle | Remarque |
|---|---|---|
| D0 (RXI), D1 (TXO) | Port série (UART) | Reliées au connecteur de programmation ; débranche tout module sur ces broches pendant le téléversement |
| D2, D3 | Interruption externe (INT0, INT1) | Les meilleures broches pour réveiller la carte |
| D3, D5, D6, D9, D10, D11 | PWM (analogWrite) | Comme sur l'Uno |
| D10, D11, D12, D13 | SPI (SS, MOSI, MISO, SCK) | nRF24L01, carte SD, écran TFT |
| D13 | LED intégrée | Partagée avec l'horloge SPI ; la LED scintille quand le SPI est utilisé |
| A0–A3 | Entrée analogique ou broche numérique | Sur le grand côté |
| A4 (SDA), A5 (SCL) | I2C | À l'intérieur de la carte ; la position peut varier sur les clones |
| A6, A7 | Entrée analogique uniquement | pinMode et digitalRead ne fonctionnent pas sur ces broches |
| RAW | Entrée du régulateur | Pile ou adaptateur se branche ici |
| VCC | 3,3 V ou 5 V régulés | Sortie du régulateur ; peut aussi être alimentée directement par une source régulée |
| RST | Reset | La relier à GND redémarre la carte |
| BLK, GND, VCC, RXI, TXO, GRN | Connecteur de programmation | BLK = GND, GRN = DTR (reset automatique) |
Alimentation : RAW, VCC et le régulateur
Tu peux alimenter le Pro Mini de deux façons. Si tu branches une source non régulée (pile 9 V, 3 piles AA ou pack 7,4 V) sur la broche RAW, le petit régulateur de la carte la ramène à 3,3 V ou 5 V. Si tu disposes déjà d'une tension régulée, comme la sortie de l'adaptateur USB-TTL ou 2 piles AA, tu l'envoies directement sur VCC et le régulateur est contourné. Le régulateur intégré est en général un petit LDO d'environ 150 mA (un MIC5205 sur l'original, des équivalents sur les clones). C'est suffisant pour la carte et quelques capteurs, mais n'alimente pas par là des éléments gourmands comme des servos, de longs rubans de LED ou des modules Wi-Fi.
| Source | Broche à utiliser | Remarque |
|---|---|---|
| Pile 9 V ou adaptateur 7–12 V | RAW | Le régulateur transforme l'excédent en chaleur ; il chauffe à 12 V et à fort courant |
| Pack Li-ion 2S (7,4 V) | RAW | Convient aux deux versions |
| Élément Li-ion seul (3,0–4,2 V) | RAW (version 3,3 V) | Insuffisant pour la version 5 V |
| 2 piles AA (2,4–3,2 V) | VCC (version 3,3 V) | Contourne le régulateur ; idéal pour la plus faible consommation |
| Adaptateur USB-TTL | VCC | Pendant la programmation ; choisis 3,3 V ou 5 V selon ta version |
| 5 V déjà régulés (chargeur USB, batterie externe) | VCC (version 5 V) | Sur RAW, le régulateur manquerait de marge |
Programmation avec un adaptateur USB-TTL et reset par DTR

Faute de puce USB, il faut un adaptateur USB-TTL externe (CH340, CP2102 ou FT232) pour téléverser du code dans le Pro Mini. La carte doit redémarrer pendant le téléversement, car le bootloader n'accepte un nouveau programme que dans le court instant qui suit le démarrage. En reliant la broche DTR de l'adaptateur à la broche GRN du Pro Mini, le condensateur de 100 nF de la carte transforme le front descendant de DTR en une brève impulsion de reset, et le téléversement se fait sans toucher au bouton. L'ordre des broches correspond souvent, si bien que l'adaptateur s'enfiche directement sur le connecteur du petit côté, mais compare toujours les marquages avant.
| USB-TTL | Pro Mini | Remarque |
|---|---|---|
| GND | GND / BLK | Masse commune |
| VCC (3,3 V ou 5 V) | VCC | Règle le cavalier selon la version de la carte |
| TXD | RXI | Liaison croisée |
| RXD | TXO | Liaison croisée |
| DTR | GRN | Reset automatique |
- Dans l'IDE Arduino, choisis Outils > Type de carte > Arduino AVR Boards > Arduino Pro or Pro Mini.
- Dans Outils > Processeur, choisis l'option qui correspond à ta carte : ATmega328P (3.3V, 8 MHz) ou ATmega328P (5V, 16 MHz).
- Dans Outils > Port, choisis le port de l'adaptateur (par exemple COM3 sous Windows, /dev/cu.usbserial... ou /dev/cu.wchusbserial... sous macOS).
- Ouvre Fichier > Exemples > 01.Basics > Blink et clique sur Téléverser. La LED de D13 doit clignoter une fois par seconde.
- Si la LED change toutes les deux secondes, tu as programmé une carte 8 MHz avec l'option 16 MHz ; si elle change toutes les demi-secondes, c'est l'inverse. Corrige le processeur et téléverse à nouveau.
Si ton adaptateur n'a pas de broche DTR, tu synchronises le téléversement à la main : dès que l'IDE a fini de compiler et affiche « Uploading... » dans la fenêtre de sortie, appuie brièvement sur le bouton reset du Pro Mini. Si tu n'as aucun adaptateur, un Arduino Uno peut le remplacer temporairement : relie la broche RESET de l'Uno à GND, la broche 0 (RX) de l'Uno à RXI et la broche 1 (TX) à TXO du Pro Mini. Ici la liaison est droite et non croisée, car la puce USB de l'Uno fait déjà la traduction. Si l'erreur « stk500_getsync(): not in sync » apparaît au téléversement, consulte l'article impossible de téléverser sur l'Arduino.
Basse consommation : mode veille et bibliothèque LowPower
Un capteur mesure le plus souvent toutes les cinq minutes et ne fait rien plus de 99 % du temps entre deux mesures. Attendre avec delay() laisse le processeur tourner à pleine vitesse ; pendant ce temps, un Pro Mini 3,3 V consomme quelques milliampères. Le mode de veille le plus profond de l'ATmega328P est le power-down : l'horloge s'arrête, seuls le chien de garde (watchdog) et les interruptions externes restent actifs, et la consommation de la puce tombe à quelques microampères. La bibliothèque Low-Power de Rocket Scream (cherche « Low-Power » dans le gestionnaire de bibliothèques) réduit ces réglages de registres complexes à une seule ligne. Le watchdog compte au maximum 8 secondes, les veilles plus longues se font donc en boucle ; un bouton ou un capteur sur D2 ou D3 peut aussi réveiller la carte.
1// Pro Mini uyku testi: LED yanar, kart 8 sn uyur; D2'deki buton erken uyandırır
2// Pro Mini sleep test: the LED lights, the board sleeps 8 s; a button on D2 wakes it early
3#include <LowPower.h>
4
5const int LED = 13;
6const int WAKE_PIN = 2; // INT0, buton GND'ye / button to GND
7volatile bool buttonWake = false;
8
9void onWake() {
10 buttonWake = true; // kesmede yalnız bayrak kaldır / only set a flag in the ISR
11}
12
13void setup() {
14 pinMode(LED, OUTPUT);
15 pinMode(WAKE_PIN, INPUT_PULLUP);
16}
17
18void loop() {
19 digitalWrite(LED, HIGH);
20 delay(buttonWake ? 100 : 1000); // butonla uyandıysa kısa yan / short flash after a button wake
21 digitalWrite(LED, LOW);
22 buttonWake = false;
23
24 attachInterrupt(digitalPinToInterrupt(WAKE_PIN), onWake, LOW);
25 LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); // 8 sn ya da buton / 8 s or the button
26 detachInterrupt(digitalPinToInterrupt(WAKE_PIN));
27}powerDown() prend trois paramètres. Le premier est la durée de veille : de SLEEP_15MS à SLEEP_8S, plus SLEEP_FOREVER pour un réveil uniquement par interruption. L'oscillateur du watchdog est moins précis qu'un quartz : une veille de 8 secondes peut varier d'environ 10 % selon la température et la tension ; pour une heure précise, mieux vaut réveiller la carte avec la sortie d'alarme d'un module RTC. Le deuxième paramètre coupe le CAN pendant la veille. Le troisième désactive le détecteur de sous-tension (BOD) en veille et fait gagner environ 20 µA de plus. Avec attachInterrupt, le réveil se fait sur D2 et D3 (les autres broches demandent une interruption de changement d'état) ; en mode power-down, ces deux broches ne réagissent qu'à un niveau LOW, c'est pourquoi le code utilise LOW et détache l'interruption dès le réveil.
Descendre aux microampères en retirant la LED et le régulateur
Quand la carte dort, le processeur ne consomme presque rien, et pourtant tu mesures encore 1–3 mA. Deux composants de la carte en sont responsables : la LED d'alimentation, toujours allumée, consomme à elle seule 1–3 mA, et le régulateur tire du courant pour son propre circuit interne même à vide (environ 80 µA pour les régulateurs de type MIC5205). En retirant ces deux composants, le Pro Mini descend à environ 4–5 µA avec le watchdog actif, et sous 1 µA lorsqu'il dort en attendant uniquement une interruption externe. Le tableau donne des valeurs typiques pour une carte 3,3 V / 8 MHz et l'autonomie théorique avec les quelque 2000 mAh de deux piles AA. Pour calculer avec tes propres valeurs, utilise le calculateur d'autonomie de batterie.
| État (3,3 V / 8 MHz) | Courant approximatif | Autonomie théorique avec 2000 mAh |
|---|---|---|
| Ne dort jamais, attend avec delay() | 4–5 mA | Environ 17–21 jours |
| Veille avec LowPower, carte d'origine | 1–3 mA | Environ 1–3 mois |
| LED d'alimentation retirée | Environ 80–100 µA (selon le régulateur) | Environ 2–3 ans |
| LED et régulateur retirés, veille watchdog de 8 s | Environ 4–5 µA | Plus de 40 ans sur le papier ; en pratique, l'autodécharge de la pile limite |
| LED et régulateur retirés, SLEEP_FOREVER | Moins de 1 µA | Limité par la durée de conservation de la pile |
- Mesure d'abord le courant de veille : règle le multimètre sur le calibre mA et branche-le en série entre le plus de la pile et la broche d'alimentation de la carte. Quand la valeur passe sous 1 mA, passe au calibre µA.
- Repère la LED d'alimentation : c'est la petite LED qui reste allumée dès que la carte est alimentée (celle de D13 est celle qui clignote). Chauffe tour à tour ses deux extrémités au fer et soulève-la, ou retire la résistance série voisine ; couper sa piste au cutter fonctionne aussi.
- Repère le régulateur : c'est le petit composant SOT-23 à cinq pattes près de la broche RAW. Ajoute beaucoup d'étain sur les pattes et chauffe-les toutes ensemble pour le retirer.
- Sans régulateur, la broche RAW ne fonctionne plus. Alimente la carte directement par VCC, entre 1,8 et 3,6 V pour la version 3,3 V : deux piles AA, un élément LiFePO4, ou un élément Li-ion derrière un régulateur qui ne consomme que quelques microampères à vide, comme le HT7333 ou le MCP1700.
- Mesure à nouveau. Si tu n'es pas autour de 4–5 µA, le coupable est très probablement un module branché : les LED et régulateurs des modules consomment exactement de la même façon.
Un capteur qui tient des mois sur piles : NTC et nRF24L01

Assemblons maintenant le tout : un Pro Mini 3,3 V se réveille toutes les cinq minutes, mesure la température avec une thermistance CTN et sa propre tension d'alimentation, envoie le résultat à un récepteur avec un nRF24L01 et se rendort. Deux astuces sont importantes. D'abord, le pont de la CTN n'est pas relié à 5V ou VCC mais à une broche numérique ; il ne consomme donc que pendant les quelques millisecondes de la mesure. Un pont de 10 kΩ + 10 kΩ alimenté en permanence sous 3 V gaspillerait 150 µA, trente fois le courant de veille. Ensuite, aucune pièce supplémentaire n'est nécessaire pour la tension de la pile : le code calcule VCC en millivolts en comparant la référence interne de 1,1 V de l'ATmega328P à l'alimentation. Comme la mesure de la CTN est ratiométrique, la température reste juste même quand la tension baisse.
| Composant | Pro Mini (3,3 V) | Remarque |
|---|---|---|
| nRF24L01 VCC / GND | VCC / GND | 3,3 V uniquement ; place un condensateur de 10–100 µF sur les broches du module |
| nRF24L01 CE / CSN | D9 / D10 | RF24 radio(9, 10) dans le code |
| nRF24L01 SCK / MOSI / MISO | D13 / D11 / D12 | Broches SPI matérielles |
| Alimentation du pont CTN | D4 → 10 kΩ → A0 | À HIGH seulement pendant la mesure |
| CTN 10 kΩ (B = 3950) | A0 → CTN → GND | Peut être déportée jusqu'au point de mesure |
| Pile | VCC et GND (régulateur retiré) | 2 piles AA ou LiFePO4 |
1// Pille çalışan sıcaklık düğümü: Pro Mini 3,3 V + NTC + nRF24L01
2// Battery-powered temperature node: Pro Mini 3.3 V + NTC + nRF24L01
3#include <SPI.h>
4#include <RF24.h>
5#include <LowPower.h>
6
7RF24 radio(9, 10); // CE, CSN
8const byte ADDRESS[6] = "NODE1"; // alıcıyla aynı adres / same address as the receiver
9const int NTC_PWR = 4; // bölücüyü besleyen pin / pin that powers the divider
10const int NTC_PIN = A0;
11const int SLEEP_CYCLES = 37; // 37 x 8 sn = yaklaşık 5 dk / about 5 minutes
12const float R_FIXED = 10000.0; // sabit direnç / fixed resistor
13const float R0 = 10000.0; // NTC'nin 25 °C direnci / NTC resistance at 25 °C
14const float BETA = 3950.0; // NTC B katsayısı / NTC beta coefficient
15const float T0 = 298.15; // 25 °C kelvin / 25 °C in kelvin
16const byte UNUSED[] = {2, 3, 5, 6, 7, 8, A1, A2, A3};
17
18struct Packet {
19 uint8_t nodeId;
20 int16_t tempC10; // 23,4 °C -> 234
21 uint16_t vccMv; // pil gerilimi (mV) / battery voltage (mV)
22 uint16_t counter;
23};
24Packet pkt = {1, 0, 0, 0};
25
26long readVccMv() {
27 ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); // AVcc'ye karşı 1,1 V / 1.1 V against AVcc
28 delay(2);
29 ADCSRA |= _BV(ADSC);
30 while (bit_is_set(ADCSRA, ADSC)) {}
31 return 1100L * 1024L / ADCW;
32}
33
34float readTempC() {
35 digitalWrite(NTC_PWR, HIGH); // bölücüye yalnız şimdi güç ver / power the divider only now
36 delay(2);
37 analogRead(NTC_PIN); // ilk okumayı at / discard the first reading
38 int raw = analogRead(NTC_PIN);
39 digitalWrite(NTC_PWR, LOW);
40 raw = constrain(raw, 1, 1022);
41 float rNtc = R_FIXED * raw / (1024.0 - raw); // oransal, VCC'den bağımsız / ratiometric
42 return 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;
43}
44
45void setup() {
46 for (byte i = 0; i < sizeof(UNUSED); i++) pinMode(UNUSED[i], INPUT_PULLUP); // boşta kalmasın / no floating pins
47 pinMode(NTC_PWR, OUTPUT);
48 digitalWrite(NTC_PWR, LOW);
49
50 radio.begin();
51 radio.setPALevel(RF24_PA_LOW);
52 radio.setDataRate(RF24_250KBPS); // daha uzun menzil / longer range
53 radio.setRetries(5, 5);
54 radio.openWritingPipe(ADDRESS);
55 radio.stopListening();
56 radio.powerDown(); // yaklaşık 1 µA / about 1 µA
57}
58
59void loop() {
60 pkt.vccMv = readVccMv();
61 pkt.tempC10 = (int16_t)(readTempC() * 10.0);
62 pkt.counter++;
63
64 radio.powerUp();
65 delay(5); // osilatör otursun / let the oscillator settle
66 radio.write(&pkt, sizeof(pkt));
67 radio.powerDown();
68
69 for (int i = 0; i < SLEEP_CYCLES; i++) {
70 LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
71 }
72}À chaque réveil, le nœud consomme quelques milliampères (environ 10 mA pendant l'émission du nRF24) pendant 20–40 ms environ. Fonctionner 40 ms toutes les cinq minutes n'ajoute qu'environ 1 µA à la moyenne ; le reste correspond au courant de veille d'environ 4–5 µA et au 1 µA du nRF24 en attente. La moyenne reste donc sous 10 µA et, sur le papier, deux piles AA tiennent des décennies ; en pratique, c'est la durée de conservation des piles qui fixe la limite. Le compteur du paquet permet au récepteur de repérer les paquets perdus, et vccMv t'indique quand changer les piles. Comme récepteur, un Uno ou un Nano branché en USB convient ; avec la même bibliothèque RF24, appelle openReadingPipe(1, ADDRESS) et startListening(), puis lis les données avec la même définition de Packet.
Arduino Pro Mini ou Nano ?

| Caractéristique | Arduino Pro Mini | Arduino Nano (V3) |
|---|---|---|
| Taille | 18 × 33 mm | 18 × 45 mm |
| USB | Non, adaptateur USB-TTL nécessaire | Oui (mini USB, CH340 ou FT232) |
| Versions | 3,3 V / 8 MHz et 5 V / 16 MHz | 5 V / 16 MHz uniquement |
| Mémoire programme utilisable | 30 Ko | 30 Ko (ancien bootloader) ou 31,5 Ko (nouveau bootloader) |
| Entrées analogiques | 8 (A0–A7) | 8 (A0–A7) |
| Courant de veille | 1–3 mA ; quelques µA sans LED ni régulateur | De l'ordre du mA à cause de la puce USB, de la LED et du régulateur |
| Breadboard | S'enfiche une fois les barrettes soudées | Disponible avec barrettes déjà soudées |
| Débogage au moniteur série | Tant que l'adaptateur est branché | À tout moment par le câble USB |
| Idéal pour | Petits montages définitifs sur piles | Apprentissage, prototypes et projets reliés en USB |
En résumé, l'Arduino Nano est plus pratique pour apprendre et prototyper : tu branches le câble USB, tu téléverses le code et tu débogues au moniteur série. Une fois le projet stabilisé, tu passes au Pro Mini s'il doit fonctionner sur piles, tenir dans un petit boîtier ou dialoguer avec des modules 3,3 V sans convertisseur de niveau. Le même code tournant sur les deux cartes, la transition se résume souvent à changer le processeur sélectionné. Dans les projets à nombreuses cartes, un seul adaptateur USB-TTL suffit pour tous les Pro Mini, ce qui réduit le coût par carte.
Idées de projets avec l'Arduino Pro Mini
- Réseau de température sans fil : place un nœud Pro Mini + nRF24 dans chaque pièce et regroupe les données sur un seul récepteur.
- Capteur de porte et fenêtre sur piles : avec un interrupteur reed sur D2, la carte dort en SLEEP_FOREVER et ne se réveille que pour signaler l'ouverture.
- Gardien d'humidité pour plantes : alimente le capteur d'humidité du sol depuis une broche numérique et mesure une fois par heure ; comme il n'est pas alimenté en permanence, la pile et les électrodes durent plus longtemps.
- Télécommande de poche : fabrique une télécommande de télé ou de climatiseur avec une LED IR et quelques boutons ; adapte côté émission les codes de l'article récepteur IR et télécommande.
- Lumières à porter : couds quelques LED WS2812B sur une veste ou un sac pour un effet lumineux animé.
- Enregistreur de données : construis un enregistreur caché dans un boîtier qui note pendant des semaines la température ou la tension d'une batterie avec un RTC et un module carte SD.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Erreur « stk500_getsync(): not in sync » | TX-RX reliés en direct, DTR non branché ou reset mal synchronisé | Relie TX à RXI et RX à TXO ; DTR à GRN, ou appuie sur reset au moment de « Uploading... » |
| Le code se téléverse mais le timing est deux fois trop lent ou rapide | Mauvais processeur (16 MHz au lieu de 8 MHz ou l'inverse) | Vérifie le marquage du quartz et téléverse avec la bonne option |
| Caractères incompréhensibles dans le moniteur série | Mauvais processeur ou débit différent de celui du code | Vérifie le processeur et la vitesse de Serial.begin |
| Encore plus de 1 mA en veille | LED d'alimentation, régulateur ou LED des modules | Retire la LED et le régulateur, alimente les modules depuis une broche numérique |
| Quelques centaines de µA en trop en veille | Entrées flottantes | Passe les broches inutilisées en INPUT_PULLUP |
| Le nRF24 ne marche pas ou perd des paquets | Alimenté par le VCC de la version 5 V ou tension qui chute à l'émission | Alimente le module en 3,3 V et ajoute 10–100 µF sur ses broches |
| La carte redémarre sans cesse avec deux piles AA | Tension passée sous le seuil BOD de 2,7 V | Change les piles ou utilise un élément LiFePO4 |
| digitalRead(A6) renvoie toujours la même valeur | A6 et A7 sont des entrées uniquement analogiques | Utilise analogRead ou une autre broche |
L'Arduino Pro Mini est le moyen le moins cher de transposer tout ce que tu as appris avec l'Uno sur une carte grande comme le bout d'un doigt, un appareil qui vit de quelques microampères. Teste d'abord ton code sur un Uno ou un Nano, puis transfère le même circuit sur le Pro Mini. Tous les projets LED, bouton, LDR et capteurs de l'application BlueGrays peuvent d'abord être montés pas à pas sur un Uno avec schéma et code prêt à l'emploi, puis passés sur le Pro Mini avec les mêmes numéros de broches.
Questions fréquentes
Comment programmer un Arduino Pro Mini ?
Comme il n'a pas de prise USB, on utilise un adaptateur USB-TTL à base de CH340, CP2102 ou FT232. On relie GND, VCC, TX → RXI, RX → TXO et DTR → GRN, puis on choisit dans l'IDE Arduino la carte « Arduino Pro or Pro Mini » et le bon processeur. Si DTR n'est pas relié, on appuie à la main sur le bouton reset au début du téléversement.
Faut-il choisir le Pro Mini 3,3 V ou 5 V ?
Pour un projet sur piles qui dialogue avec des modules 3,3 V comme le nRF24L01, le BME280 ou une carte SD, choisis la version 3,3 V / 8 MHz. Si tu as besoin de capteurs 5 V, de modules relais ou de plus de vitesse de calcul, la version 5 V / 16 MHz convient mieux. Les deux exécutent le même code ; seul le processeur sélectionné change.
Quelle est la consommation d'un Arduino Pro Mini ?
La version 3,3 V / 8 MHz consomme environ 4–5 mA en fonctionnement, la version 5 V / 16 MHz autour de 15–20 mA. Endormie avec LowPower, la carte d'origine consomme encore 1–3 mA, car la LED d'alimentation et le régulateur restent actifs. Une fois ces deux composants retirés, le courant de veille descend à environ 4–5 µA avec le watchdog actif.
Peut-on brancher un câble USB sur un Arduino Pro Mini ?
Non, le Pro Mini n'a ni prise ni puce USB. Il faut un adaptateur USB-TTL pour le relier à l'ordinateur ; adaptateur branché, tu alimentes la carte, tu téléverses le code et tu utilises le moniteur série. Pour travailler directement en USB, l'Arduino Nano, doté du même processeur, est plus pratique.
Pourquoi A6 et A7 ne fonctionnent-elles pas comme broches numériques sur le Pro Mini ?
Sur l'ATmega328P, les voies A6 et A7 ne sont reliées qu'au multiplexeur analogique et n'ont pas de circuit d'entrée/sortie numérique. C'est pourquoi pinMode, digitalRead et digitalWrite n'y fonctionnent pas. Pour y brancher une entrée numérique comme un bouton, utilise une résistance de tirage externe et vérifie avec analogRead si la valeur est au-dessus ou en dessous de 512.
Combien de temps un Arduino Pro Mini tient-il sur piles ?
Tout dépend du courant de veille. Une carte qui ne dort jamais tient environ trois semaines avec deux piles AA, et une carte qui dort avec LowPower sans autre modification, 1 à 3 mois. Sans LED d'alimentation ni régulateur, le courant moyen passe sous 10 µA et les mêmes piles durent des années ; c'est alors l'autodécharge qui fixe la limite.
Projets à réaliser après cet article
Voir tous les projets
Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Allumer une LED avec un bouton-poussoir (Push)
Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

Mesurer l'intensité lumineuse avec une LDR
Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

Communication unidirectionnelle entre 2 Arduino
Tu fais discuter deux Arduino par un seul fil : appuie sur le bouton de l'un et la LED de l'autre s'allume, appuie encore et elle s'éteint.

Détecteur de mouvement avec capteur de mouvement
Un gardien tout simple qui te prévient quand quelqu'un entre dans la pièce. Le détecteur de mouvement repère la chaleur dégagée par le corps humain ; l'Arduino garde la LED allumée tant qu'il y a du…

Capteur de porte avec interrupteur reed
Sache si ta porte est ouverte ou fermée rien qu'en regardant une lumière. Tu fixes un petit aimant sur la porte et sur le cadre un interrupteur qui sent les aimants ; porte fermée, ils sont côte à…
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

