Brochage Arduino Mega 2560 : PWM, Série, Interruptions
Brochage Arduino Mega : 54 broches numériques, 16 analogiques, 15 PWM, 4 ports série et 6 interruptions. Comparaison avec l'Uno, exemples et imprimante 3D.
Le brochage de l'Arduino Mega offre le plus de possibilités de connexion de toute la famille Arduino : la carte Arduino Mega 2560 dispose de 54 entrées/sorties numériques, 16 entrées analogiques, 15 sorties PWM, 4 ports série matériels et 6 broches d'interruption externe. Quand les broches de l'Uno ne suffisent plus, quand tu dois faire parler plusieurs appareils série en même temps (GPS, Bluetooth, GSM) ou quand la mémoire programme est pleine, la Mega est la première carte à laquelle on pense. Elle utilise le même langage Arduino, le même IDE et la grande majorité des mêmes bibliothèques que l'Uno : tu progresses sans rien réapprendre.
Dans ce guide, on parcourt la carte des broches de la Mega groupe par groupe : quelles broches font du PWM, où se trouve chaque port série, où fonctionnent les interruptions et pourquoi l'I2C et le SPI ne sont pas au même endroit que sur l'Uno. On continue avec un tableau comparatif avec l'Uno, les cas où la Mega est vraiment utile, pourquoi elle est devenue un standard sur les imprimantes 3D et comment planifier les broches d'un projet à plusieurs capteurs.

Qu'est-ce que l'Arduino Mega 2560 et comment fonctionne-t-elle ?
L'Arduino Mega 2560 est une carte de développement construite autour du microcontrôleur 8 bits ATmega2560. Elle tourne à la même fréquence de 16 MHz que l'Uno, utilise le même niveau logique de 5 V et se programme avec le même IDE Arduino : la Mega n'est donc pas plus rapide que l'Uno, elle est simplement plus large. Son boîtier à 100 broches permet de sortir 70 broches de signal. La liaison USB est assurée par la puce ATmega16U2 de la carte, et par une CH340 sur la plupart des clones. Tu peux l'alimenter en 5 V par l'USB, ou en 7–12 V par la prise jack et Vin ; le régulateur interne ramène cette tension à 5 V. Sa mémoire programme est 8 fois celle de l'Uno et sa RAM 4 fois plus grande : les grosses bibliothèques, les écrans graphiques et les longs menus y passent donc sans problème. La moitié gauche de la carte a le même brochage que l'Uno, ce qui permet d'enficher directement la plupart des shields Uno sur la Mega.
| Caractéristique | Valeur |
|---|---|
| Microcontrôleur | ATmega2560 (AVR 8 bits) |
| Fréquence d'horloge | 16 MHz |
| Mémoire flash | 256 Ko (dont 8 Ko pour le bootloader) |
| SRAM | 8 Ko |
| EEPROM | 4 Ko |
| Tension de fonctionnement | 5 V |
| Tension d'entrée (jack / Vin) | 7–12 V recommandés, limites 6–20 V |
| E/S numériques | 54 (dont 15 PWM) |
| Entrées analogiques | 16 (A0–A15, 10 bits) |
| Ports série matériels | 4 (Serial, Serial1, Serial2, Serial3) |
| Broches d'interruption externe | 6 |
| Courant par broche | 20 mA recommandés, 40 mA maximum absolu |
| Courant de la broche 3.3V | 50 mA maximum |
| Dimensions | 101,5 × 53,3 mm |
Comparaison entre l'Arduino Mega et l'Uno
| Caractéristique | Arduino Uno R3 | Arduino Mega 2560 |
|---|---|---|
| Microcontrôleur | ATmega328P | ATmega2560 |
| Fréquence d'horloge | 16 MHz | 16 MHz |
| Broches numériques | 14 | 54 |
| Broches PWM | 6 (3, 5, 6, 9, 10, 11) | 15 (2–13, 44, 45, 46) |
| Entrées analogiques | 6 (A0–A5) | 16 (A0–A15) |
| Ports série matériels | 1 | 4 |
| Broches d'interruption externe | 2 (2, 3) | 6 (2, 3, 18, 19, 20, 21) |
| Flash / SRAM / EEPROM | 32 Ko / 2 Ko / 1 Ko | 256 Ko / 8 Ko / 4 Ko |
| Broches I2C | A4 (SDA), A5 (SCL) | 20 (SDA), 21 (SCL) |
| Broches SPI | 10, 11, 12, 13 | 53, 51, 50, 52 |
| Dimensions | 68,6 × 53,4 mm | 101,5 × 53,3 mm |
Brochage de l'Arduino Mega : tous les groupes de broches
| Groupe de broches | Numéros de broches | Rôle et remarques |
|---|---|---|
| Broches numériques communes avec l'Uno | 0–13 | 0 (RX0) et 1 (TX0) forment la liaison série USB ; la LED intégrée est sur la 13 |
| Broches des ports série supplémentaires | 14–19 | 14 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1 |
| I2C | 20 (SDA), 21 (SCL) | Bibliothèque Wire ; la carte a des résistances de rappel de 10 kΩ vers 5 V |
| Double connecteur numérique | 22–53 | E/S généralistes ; pas de PWM sauf 44, 45 et 46 |
| PWM | 2–13, 44, 45, 46 | S'utilise avec analogWrite(broche, 0–255) |
| SPI | 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS) | Les mêmes signaux sont aussi sur le connecteur ICSP |
| Entrées analogiques | A0–A15 (numériques 54–69) | Lues avec analogRead, utilisables aussi comme broches numériques |
| Alimentation et contrôle | 5V, 3.3V, Vin, GND, IOREF, AREF, RESET | AREF est l'entrée de référence analogique externe ; la carte redémarre quand RESET passe à LOW |
Broches PWM et timers
La Mega a 15 sorties PWM : les 12 broches de 2 à 13, plus 44, 45 et 46. Avec analogWrite(broche, 0–255), tu règles la luminosité d'une LED ou la vitesse d'un moteur. Les signaux PWM sont générés par six timers matériels (Timer0 à Timer5) ; Timer0 et Timer2 font 8 bits, les autres 16 bits. Comme Timer0 gère aussi millis() et delay(), les broches 4 et 13 tournent à environ 980 Hz et les autres broches PWM à environ 490 Hz. Le point d'attention principal : quand une bibliothèque s'empare d'un timer, le PWM des broches liées à ce timer est perturbé. La bibliothèque Servo utilise Timer5 pour les 12 premiers servos sur la Mega ; dès que tu branches un servo, analogWrite ne fonctionne plus sur 44, 45 et 46, et tone() utilise Timer2, ce qui touche les broches 9 et 10. Tu trouveras le duty cycle et la fréquence en détail dans Qu'est-ce que le PWM ?.
| Timer | Broches PWM | Fréquence par défaut | Conflit avec |
|---|---|---|---|
| Timer0 (8 bits) | 4, 13 | ~980 Hz | millis() et delay() |
| Timer1 (16 bits) | 11, 12 | ~490 Hz | Bibliothèque Servo (13e–24e servo) |
| Timer2 (8 bits) | 9, 10 | ~490 Hz | Fonction tone() |
| Timer3 (16 bits) | 2, 3, 5 | ~490 Hz | Bibliothèque Servo (25e–36e servo) |
| Timer4 (16 bits) | 6, 7, 8 | ~490 Hz | Bibliothèque Servo (37e–48e servo) |
| Timer5 (16 bits) | 44, 45, 46 | ~490 Hz | Bibliothèque Servo (12 premiers servos) |
4 ports série matériels : Serial, Serial1, Serial2, Serial3
L'Uno n'a qu'un seul port série matériel, partagé avec l'USB ; pour un deuxième appareil, tu es obligé d'utiliser SoftwareSerial. SoftwareSerial peut perdre des données à haute vitesse, n'écoute qu'un seul port à la fois et ralentit le reste du code car il désactive les interruptions pendant la réception d'un octet. La Mega, elle, possède quatre UART matériels indépendants ; chacun travaille en arrière-plan avec son propre tampon de réception de 64 octets, donc les données reçues ne sont pas perdues pendant que loop() fait autre chose. La règle de câblage est la même pour chaque port : le TX du module va au RX de la Mega, le RX du module va au TX de la Mega, et les GND sont toujours communs. Quand un module fonctionne en logique 3,3 V, ramène le signal TX 5 V de la Mega à environ 3,3 V avec un diviseur de tension de 1 kΩ et 2 kΩ avant l'entrée RX du module. Le code de pont ci-dessous envoie vers Serial1 ce que tu écris dans le moniteur série, et renvoie vers le moniteur ce qui vient de Serial1 ; c'est la façon la plus rapide de tester un module comme le HC-05. Pour comprendre le fonctionnement de l'UART, lis la communication série UART.
| Port | Broche TX | Broche RX | Usage typique |
|---|---|---|---|
| Serial | 1 | 0 | USB et moniteur série |
| Serial1 | 18 | 19 | Module Bluetooth HC-05 |
| Serial2 | 16 | 17 | Module GPS NEO-6M |
| Serial3 | 14 | 15 | SIM800L GSM ou lecteur d'empreintes |
1// USB Seri Monitör <-> Serial1 köprüsü / USB Serial Monitor <-> Serial1 bridge
2// Serial1: TX1 = 18, RX1 = 19
3
4void setup() {
5 Serial.begin(9600); // bilgisayar (USB) / computer (USB)
6 Serial1.begin(9600); // HC-05, GPS vb. / HC-05, GPS, etc.
7 Serial.println(F("Mega seri kopru hazir / serial bridge ready"));
8}
9
10void loop() {
11 if (Serial1.available()) { // modülden gelen veri / data from the module
12 Serial.write(Serial1.read());
13 }
14 if (Serial.available()) { // Seri Monitör'den gelen veri / data from the Serial Monitor
15 Serial1.write(Serial.read());
16 }
17}Broches d'interruption
Une interruption externe te permet de détecter un changement sur une broche en quelques microsecondes, quoi que fasse loop() à ce moment-là ; c'est idéal pour les encodeurs, les capteurs de débit d'eau, les compte-tours et les boutons qui doivent réagir vite. Sur la Mega, 6 broches sont utilisables avec attachInterrupt : 2, 3, 18, 19, 20 et 21. Les numéros d'interruption ne suivent pas l'ordre des broches (2 → 0, 3 → 1, 21 → 2, 20 → 3, 19 → 4, 18 → 5) ; utilise donc toujours digitalPinToInterrupt(broche) au lieu d'écrire le numéro à la main. Attention : 18 et 19 sont les broches de Serial1, et 20 et 21 celles de l'I2C ; si tu utilises Serial1 et l'I2C, il ne te reste que 2 et 3. Si tu as besoin de plus de broches, les interruptions de changement de broche (PCINT) de l'ATmega2560 fonctionnent sur 10–15, 50–53 et A8–A15 et s'utilisent avec les bibliothèques adaptées. Le code ci-dessous compte les impulsions sur les broches 2 et 18 ; les fonctions d'interruption sont courtes, les compteurs partagés sont déclarés volatile et les interruptions sont brièvement suspendues pendant la lecture. Dans cet exemple, la broche 18 étant réservée à l'interruption, Serial1 n'est pas utilisable. Pour approfondir, lis l'article Arduino interrupt.
1// Arduino Mega: 2 ve 18 numaralı pinlerde darbe sayma / pulse counting on pins 2 and 18
2volatile unsigned long countA = 0; // pin 2
3volatile unsigned long countB = 0; // pin 18
4
5void onPulseA() { countA++; } // kısa tut / keep it short
6void onPulseB() { countB++; }
7
8void setup() {
9 Serial.begin(115200);
10 pinMode(2, INPUT_PULLUP); // buton ya da sensör GND'ye çeker / button or sensor pulls to GND
11 pinMode(18, INPUT_PULLUP);
12 attachInterrupt(digitalPinToInterrupt(2), onPulseA, FALLING);
13 attachInterrupt(digitalPinToInterrupt(18), onPulseB, FALLING);
14}
15
16void loop() {
17 noInterrupts(); // okurken kesmeleri durdur / pause interrupts while reading
18 unsigned long a = countA;
19 unsigned long b = countB;
20 interrupts();
21
22 Serial.print(F("Pin 2: "));
23 Serial.print(a);
24 Serial.print(F(" Pin 18: "));
25 Serial.println(b);
26 delay(500);
27}16 entrées analogiques (A0–A15)
Les 16 entrées analogiques de la Mega partagent un seul CAN de 10 bits via un multiplexeur. Chaque lecture renvoie une valeur de 0 à 1023 ; avec une référence de 5 V, un pas correspond à environ 4,9 mV. Une conversion dure environ 100 microsecondes, tu peux donc faire quelque 10 000 lectures par seconde : balayer les 16 canaux l'un après l'autre ne pose aucun problème. Pour une mesure plus précise, analogReference te permet de choisir la référence interne de 1,1 V (INTERNAL1V1) ou de 2,56 V (INTERNAL2V56) ; l'option INTERNAL de l'Uno n'existe pas sur la Mega. Les broches analogiques servent aussi de broches numériques : A0 est la broche numérique 54 et A15 la 69, et pinMode(A8, OUTPUT) te permet d'allumer une LED avec cette broche. Lors d'un changement rapide de canal, la tension du canal précédent peut fuir dans la mesure suivante ; avec des sources dont l'impédance dépasse 10 kΩ, lire chaque canal deux fois et jeter la première valeur réduit cette erreur. Le fonctionnement du CAN est expliqué dans la conversion analogique-numérique.
1// 16 analog kanalı sırayla oku / read all 16 analog channels in turn
2void setup() {
3 Serial.begin(115200);
4}
5
6void loop() {
7 for (byte ch = 0; ch < 16; ch++) {
8 int raw = analogRead(A0 + ch); // A0..A15 = 54..69
9 float volts = raw * (5.0 / 1023.0); // ham değeri volta çevir / convert raw value to volts
10 Serial.print(F("A"));
11 Serial.print(ch);
12 Serial.print(F("="));
13 Serial.print(volts, 2);
14 if (ch < 15) {
15 Serial.print(F(" "));
16 }
17 }
18 Serial.println(); // satır sonu / end of line
19 delay(1000);
20}Broches I2C et SPI : compatibilité avec les shields Uno
La différence qui piège le plus de monde en passant à la Mega, c'est l'emplacement des broches de communication. Sur l'Uno, l'I2C est sur A4 et A5 et le SPI sur 10–13 ; sur la Mega, l'I2C est sur 20 (SDA) et 21 (SCL) et le SPI sur 50–53. Sur les cartes R3, SDA et SCL sont aussi répétées sur le connecteur à côté d'AREF, et les signaux SPI se trouvent au même endroit sur les deux cartes, sur le connecteur ICSP de 6 broches au centre. Les shields qui prennent le SPI sur l'ICSP fonctionnent donc sans souci sur la Mega, alors que les anciens shields qui le prennent directement sur 11–13 ne fonctionneront pas. Les bibliothèques Wire et SPI utilisent d'elles-mêmes les bonnes broches : ton rôle est de brancher les fils au bon endroit. En SPI, tu peux relier la broche CS de l'appareil à n'importe quelle broche numérique, mais ne configure jamais la 53 en entrée : si elle est en entrée et passe à LOW, le processeur bascule en mode esclave SPI et la communication s'arrête. Par exemple, tu branches un lecteur RFID RC522 ainsi : SDA → 53, SCK → 52, MOSI → 51, MISO → 50. Pour le détail des protocoles, lis Qu'est-ce que l'I2C ? et Qu'est-ce que le SPI ?.
| Signal | Arduino Uno | Arduino Mega | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| I2C SDA | A4 | 20 | GPIO 21 | GP4 |
| I2C SCL | A5 | 21 | GPIO 22 | GP5 |
| SPI MISO | 12 | 50 | GPIO 19 | GP16 |
| SPI MOSI | 11 | 51 | GPIO 23 | GP19 |
| SPI SCK | 13 | 52 | GPIO 18 | GP18 |
| SPI SS / CS | 10 | 53 | GPIO 5 | GP17 |
| Port série supplémentaire TX / RX | Aucun (SoftwareSerial) | 18 / 19 (Serial1) | GPIO 17 / 16 (Serial2) | GP0 / GP1 (UART0) |
| Niveau logique | 5 V | 5 V | 3,3 V | 3,3 V |
Pas à pas : premier programme sur la Mega (chenillard de 16 LED)
- Branche la Mega à l'ordinateur avec un câble USB-B ; si la puce USB de ton clone est une CH340, installe d'abord son pilote.
- Dans l'IDE Arduino, choisis Arduino Mega or Mega 2560 dans le menu Outils > Type de carte, et laisse le processeur sur ATmega2560 (Mega 2560).
- Choisis le port de la carte dans Outils > Port (par exemple COM3 sous Windows, un nom commençant par /dev/cu.usbmodem ou /dev/cu.wchusbserial sous macOS).
- Branche 16 LED sur les broches 22 à 37, chacune avec une résistance de 220 Ω, et relie les pattes courtes des LED (cathodes) à la ligne GND. Avec une LED rouge, il circule (5 − 2) / 220 ≈ 13,6 mA ; pour d'autres couleurs, utilise le calculateur de résistance de LED.
- Téléverse le code ci-dessous ; les LED s'allument l'une après l'autre. Comme une seule LED est allumée à la fois, le courant total reste sous 20 mA. Tu trouveras l'effet d'aller-retour dans Knight Rider et chenillard de LED.
1// Arduino Mega: 22-37 pinlerinde 16 LED'li yürüyen ışık / 16-LED chaser on pins 22-37
2const byte FIRST_PIN = 22; // ilk LED pini / first LED pin
3const byte LED_COUNT = 16; // 22..37
4
5void setup() {
6 for (byte i = 0; i < LED_COUNT; i++) {
7 pinMode(FIRST_PIN + i, OUTPUT); // tüm LED pinleri çıkış / all LED pins as outputs
8 }
9}
10
11void loop() {
12 for (byte i = 0; i < LED_COUNT; i++) {
13 digitalWrite(FIRST_PIN + i, HIGH); // LED'i yak / turn LED on
14 delay(60);
15 digitalWrite(FIRST_PIN + i, LOW); // LED'i söndür / turn LED off
16 }
17}Quand a-t-on besoin d'une Arduino Mega ?
- Quand les broches ne suffisent pas : un clavier 4x4 demande 8 broches à lui seul, un LCD en parallèle 6 ; avec des relais, des boutons et des capteurs en plus, les 20 broches de l'Uno sont vite épuisées.
- Quand tu as plusieurs appareils série : écouter un GPS, un Bluetooth et un GSM en même temps est quasi impossible sur l'Uno ; sur la Mega, chacun a son port matériel.
- Quand la mémoire est pleine : si le compilateur signale un manque de mémoire ou si tu combines écran TFT, carte SD et code de menu, les 256 Ko de flash et 8 Ko de RAM apportent un grand confort ; détails dans Arduino : mémoire insuffisante.
- Quand tu as beaucoup de capteurs analogiques : grâce aux 16 canaux, tu lis humidité du sol, gaz, lumière et potentiomètres sans multiplexeur.
- Pour les robots à nombreux servos : la bibliothèque Servo gère jusqu'à 48 servos sur la Mega (12 sur l'Uno) ; c'est adapté à un bras robotisé ou à un robot marcheur.
- Quand la Mega n'est pas nécessaire : si tu as besoin de Wi-Fi, de vitesse ou de faible consommation, l'ESP32 est plus judicieux (Arduino ou ESP32 ?) ; s'il te manque seulement quelques sorties, multiplier les broches de l'Uno avec un registre à décalage 74HC595 est plus économique et plus compact.
Arduino Mega et RAMPS 1.4 sur les imprimantes 3D
Pendant des années, la plupart des imprimantes 3D maison et des petites CNC ont fonctionné avec une Arduino Mega et la carte RAMPS 1.4 enfichée dessus ; ce duo reste aujourd'hui l'électronique d'imprimante pédagogique la plus répandue. La raison est simple : un firmware comme Marlin, avec écran et carte SD, dépasse facilement 100 Ko ; et cinq drivers de moteurs pas à pas (X, Y, Z et deux extrudeurs), trois sorties MOSFET, six fins de course, des thermistances, un LCD et une carte SD demandent des dizaines de broches. Sur la RAMPS, les signaux step et direction de l'axe X sont sur 54 et 55 (A0 et A1), ceux de l'axe Y sur 60 et 61 (A6 et A7), ceux de l'axe Z sur 46 et 48, et ceux du premier extrudeur sur 26 et 28. Le chauffage de la buse est piloté par la broche PWM 10, le plateau chauffant par la 8 et le ventilateur par la 9 ; les thermistances de la buse et du plateau sont lues sur A13 et A14. Cette répartition montre bien comment les broches analogiques peuvent servir efficacement de sorties numériques. Pour le réglage du courant et du micro-pas des drivers, consulte l'article driver de moteur pas à pas A4988.
Exemple de projet multi-capteurs : bien planifier les broches
| Module | Broche de la Mega | Pourquoi cette broche ? |
|---|---|---|
| Bluetooth HC-05 | 18 (TX1), 19 (RX1) | La communication avec le téléphone passe par un port série matériel, sans perte de données |
| GPS NEO-6M | 16 (TX2), 17 (RX2) | Le GPS envoie de nombreuses lignes chaque seconde et veut un port dédié |
| GSM SIM800L | 14 (TX3), 15 (RX3) | Troisième port indépendant pour les SMS et les appels |
| LCD I2C + BME280 | 20 (SDA), 21 (SCL) | Deux appareils partagent la même ligne I2C avec des adresses différentes |
| RFID RC522 | 50, 51, 52, 53 + RST 49 | Bus SPI matériel, avec la 53 comme CS |
| Capteur d'humidité du sol (4) | A0–A3 | Les quatre premiers des 16 canaux analogiques |
| Capteur de gaz MQ-2 | A4 | Capteur à sortie analogique |
| Capteur de débit d'eau | 2 | Broche d'interruption externe pour ne pas manquer d'impulsions |
| Module relais 8 voies | 22–29 | Simples sorties numériques, sans besoin de PWM |
| Ventilateur (via MOSFET) | 6 | PWM pour régler la vitesse (Timer4) |
| Servo (trappe) | 8 | Le signal servo peut sortir de n'importe quelle broche numérique ; Timer5 étant utilisé, 44–46 ne servent plus au PWM |
Erreurs fréquentes et solutions
| Symptôme | Cause | Solution |
|---|---|---|
| Le code ne se téléverse pas, erreur de délai avrdude | Carte restée sur Uno, mauvais port ou module branché sur les broches 0 et 1 | Choisis Mega 2560 et le bon port dans le menu Outils, et débranche les fils des broches 0 et 1 pendant le téléversement |
| L'écran ou le capteur I2C n'est pas détecté | Fils branchés sur A4 et A5 par habitude de l'Uno | Branche SDA sur 20 et SCL sur 21 |
| Le module SPI du shield ne fonctionne pas | Le shield prend les signaux SPI sur les broches 11–13 | Utilise le connecteur ICSP ou les broches 50–52 |
| analogWrite s'arrête sur 44–46 après ajout d'un servo | La bibliothèque Servo utilise Timer5 | Déplace la sortie PWM sur une broche entre 2 et 13 |
| SoftwareSerial ne reçoit rien | La broche RX choisie ne gère pas les interruptions de changement de broche | Utilise les ports matériels Serial1, Serial2 ou Serial3 |
| La carte chauffe ou redémarre toute seule | Moteur, bobine de relais ou nombreuses LED pilotés directement par les broches | Utilise un transistor, un MOSFET ou un driver de moteur, et ajoute une alimentation externe |
| Les valeurs analogiques fluctuent sans cesse | Lecture d'une entrée flottante ou fuite entre canaux | Ne lis que les canaux où un capteur est branché, et lis chaque canal deux fois en faisant la moyenne |
L'Arduino Mega est l'étape la plus simple pour quiconque connaît l'Uno : même code, mêmes bibliothèques, mais bien plus de broches, de ports et de mémoire. Les guides brochage de l'Arduino Uno et brochage de l'Arduino Nano te seront aussi utiles pour les petits projets. Dans l'application BlueGrays, tu trouveras pas à pas, avec schéma et code, des projets gourmands en broches comme l'horloge numérique à 4 afficheurs 7 segments, la serrure à code avec clavier et LCD, le robot évitant les obstacles et le coffre électronique intelligent, et tu pourras adapter le brochage à ta propre Mega.
Questions fréquentes
Combien de broches a l'Arduino Mega ?
L'Arduino Mega 2560 a 54 entrées/sorties numériques et 16 entrées analogiques, soit 70 broches de signal au total. 15 des broches numériques fournissent du PWM, et les broches analogiques (A0–A15) peuvent aussi servir de broches numériques 54 à 69. S'y ajoutent des broches d'alimentation et de contrôle : 5V, 3.3V, Vin, GND, AREF, IOREF et RESET.
Quelles sont les broches PWM de l'Arduino Mega ?
Sur la Mega, les broches 2 à 13 ainsi que 44, 45 et 46 font du PWM, soit 15 sorties PWM au total. Les broches 4 et 13 tournent à environ 980 Hz, les autres à environ 490 Hz. Quand la bibliothèque Servo est utilisée, le PWM de 44, 45 et 46 est désactivé.
Où sont les broches SDA et SCL de l'Arduino Mega ?
Sur la Mega, la ligne I2C est sur les broches 20 (SDA) et 21 (SCL) ; sur les cartes R3, les mêmes signaux sont aussi sur le connecteur à côté d'AREF. A4 et A5 ne sont pas de l'I2C sur la Mega, ce sont de simples entrées analogiques. Le SPI est sur 50 (MISO), 51 (MOSI), 52 (SCK) et 53 (SS), ainsi que sur le connecteur ICSP.
Le code Arduino Uno fonctionne-t-il sur la Mega ?
La plupart des codes Uno se compilent et fonctionnent sur la Mega sans modification ; il suffit de choisir Mega 2560 comme carte dans le menu Outils. Les problèmes viennent généralement du matériel : l'emplacement des broches I2C et SPI diffère, et le code qui accède directement aux registres des timers et des ports doit être adapté. Passer les codes qui utilisent SoftwareSerial aux ports série matériels de la Mega donne aussi un résultat plus fiable.
Quelles sont les broches d'interruption de l'Arduino Mega ?
Les broches d'interruption externe utilisables avec attachInterrupt sont 2, 3, 18, 19, 20 et 21. Comme 18 et 19 sont partagées avec Serial1 et 20 et 21 avec l'I2C, il ne reste que 2 et 3 si tu utilises ces bus. Utilise digitalPinToInterrupt(broche) plutôt que d'écrire le numéro d'interruption à la main pour éviter les erreurs.
Peut-on brancher un capteur 3,3 V sur l'Arduino Mega ?
Oui, mais avec précaution. La Mega fonctionne en logique 5 V ; elle lit en général une sortie 3,3 V comme HIGH, mais une sortie 5 V de la Mega peut endommager une entrée 3,3 V. Utilise donc un diviseur de tension ou un convertisseur de niveau logique sur les entrées du module ; pour l'I2C, privilégie un convertisseur bidirectionnel à cause des résistances de rappel 5 V de la carte.
Projets à réaliser après cet article
Voir tous les projets
Chenillard à LED
Des lumières qui s'allument l'une après l'autre, comme si elles couraient. L'Arduino allume six LED une par une ; chacune brille un court instant puis s'éteint, et la lumière parcourt la rangée du…

Chenillard K2000 à LED
Le fameux balayage lumineux : un point de lumière glisse d'un bout à l'autre de six LED, puis revient.

HC-SR04 Mesure de la distance (affichage en série)
Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

Horloge numérique avec afficheur 7 segments à 4 chiffres
Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

Serrure à code avec clavier 4x4 et écran LCD
Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

Robot évitant les obstacles
Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

Coffre-fort électronique intelligent
Un petit coffre-fort pour tes objets précieux, qui s'ouvre avec un code. Tu tapes ton code à quatre chiffres sur le clavier ; s'il est bon, le servomoteur ouvre le verrou, la lumière verte s'allume…

Chorégraphie de servos en cercle - Motifs animés avec 32 servos
Un projet d'animation visuelle avec 32 servomoteurs disposés en cercle sur un Arduino Mega. Les servos sont gérés dans un seul tableau, branchés sur les broches 22 à 53 du Mega, et enchaînent quatre séquences : une vibration chaotique à des angles aléatoires, un balayage synchronisé, une vague qui tourne autour du cercle et une aiguille de boussole qui oscille de gauche à droite.
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

