Composants · 12 min de lecture

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.

Carte Arduino Mega 2560 et ses connecteurs
Arduino Mega 2560 : processeur ATmega2560, 54 broches numériques et 16 analogiques ; les broches numériques 22 à 53 se trouvent sur le double connecteur du bord droit.

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éristiqueValeur
MicrocontrôleurATmega2560 (AVR 8 bits)
Fréquence d'horloge16 MHz
Mémoire flash256 Ko (dont 8 Ko pour le bootloader)
SRAM8 Ko
EEPROM4 Ko
Tension de fonctionnement5 V
Tension d'entrée (jack / Vin)7–12 V recommandés, limites 6–20 V
E/S numériques54 (dont 15 PWM)
Entrées analogiques16 (A0–A15, 10 bits)
Ports série matériels4 (Serial, Serial1, Serial2, Serial3)
Broches d'interruption externe6
Courant par broche20 mA recommandés, 40 mA maximum absolu
Courant de la broche 3.3V50 mA maximum
Dimensions101,5 × 53,3 mm

Comparaison entre l'Arduino Mega et l'Uno

CaractéristiqueArduino Uno R3Arduino Mega 2560
MicrocontrôleurATmega328PATmega2560
Fréquence d'horloge16 MHz16 MHz
Broches numériques1454
Broches PWM6 (3, 5, 6, 9, 10, 11)15 (2–13, 44, 45, 46)
Entrées analogiques6 (A0–A5)16 (A0–A15)
Ports série matériels14
Broches d'interruption externe2 (2, 3)6 (2, 3, 18, 19, 20, 21)
Flash / SRAM / EEPROM32 Ko / 2 Ko / 1 Ko256 Ko / 8 Ko / 4 Ko
Broches I2CA4 (SDA), A5 (SCL)20 (SDA), 21 (SCL)
Broches SPI10, 11, 12, 1353, 51, 50, 52
Dimensions68,6 × 53,4 mm101,5 × 53,3 mm

Brochage de l'Arduino Mega : tous les groupes de broches

Groupe de brochesNuméros de brochesRôle et remarques
Broches numériques communes avec l'Uno0–130 (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émentaires14–1914 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1
I2C20 (SDA), 21 (SCL)Bibliothèque Wire ; la carte a des résistances de rappel de 10 kΩ vers 5 V
Double connecteur numérique22–53E/S généralistes ; pas de PWM sauf 44, 45 et 46
PWM2–13, 44, 45, 46S'utilise avec analogWrite(broche, 0–255)
SPI50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)Les mêmes signaux sont aussi sur le connecteur ICSP
Entrées analogiquesA0–A15 (numériques 54–69)Lues avec analogRead, utilisables aussi comme broches numériques
Alimentation et contrôle5V, 3.3V, Vin, GND, IOREF, AREF, RESETAREF est l'entrée de référence analogique externe ; la carte redémarre quand RESET passe à LOW
Chaque broche d'entrée/sortie de la Mega supporte au maximum 40 mA ; pour travailler en sécurité, reste sous 20 mA. Le courant total que le processeur peut fournir sur l'ensemble des broches est d'environ 200 mA. Ce n'est pas parce qu'il y a 54 broches qu'on peut alimenter 54 LED en direct, ni brancher un moteur ou une bobine de relais sur une broche : tu abîmerais le processeur. Pour ces charges, utilise un transistor ou un driver. De plus, les broches 0 et 1 sont reliées à la liaison série USB : si un module y est branché, le téléversement du code peut échouer.

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 ?.

TimerBroches PWMFréquence par défautConflit avec
Timer0 (8 bits)4, 13~980 Hzmillis() et delay()
Timer1 (16 bits)11, 12~490 HzBibliothèque Servo (13e–24e servo)
Timer2 (8 bits)9, 10~490 HzFonction tone()
Timer3 (16 bits)2, 3, 5~490 HzBibliothèque Servo (25e–36e servo)
Timer4 (16 bits)6, 7, 8~490 HzBibliothèque Servo (37e–48e servo)
Timer5 (16 bits)44, 45, 46~490 HzBibliothè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.

PortBroche TXBroche RXUsage typique
Serial10USB et moniteur série
Serial11819Module Bluetooth HC-05
Serial21617Module GPS NEO-6M
Serial31415SIM800L GSM ou lecteur d'empreintes
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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 ?.

SignalArduino UnoArduino MegaESP32Raspberry Pi Pico
I2C SDAA420GPIO 21GP4
I2C SCLA521GPIO 22GP5
SPI MISO1250GPIO 19GP16
SPI MOSI1151GPIO 23GP19
SPI SCK1352GPIO 18GP18
SPI SS / CS1053GPIO 5GP17
Port série supplémentaire TX / RXAucun (SoftwareSerial)18 / 19 (Serial1)GPIO 17 / 16 (Serial2)GP0 / GP1 (UART0)
Niveau logique5 V5 V3,3 V3,3 V

Pas à pas : premier programme sur la Mega (chenillard de 16 LED)

  1. 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.
  2. 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).
  3. 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).
  4. 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.
  5. 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.
C++ (Arduino IDE)
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

ModuleBroche de la MegaPourquoi cette broche ?
Bluetooth HC-0518 (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-6M16 (TX2), 17 (RX2)Le GPS envoie de nombreuses lignes chaque seconde et veut un port dédié
GSM SIM800L14 (TX3), 15 (RX3)Troisième port indépendant pour les SMS et les appels
LCD I2C + BME28020 (SDA), 21 (SCL)Deux appareils partagent la même ligne I2C avec des adresses différentes
RFID RC52250, 51, 52, 53 + RST 49Bus SPI matériel, avec la 53 comme CS
Capteur d'humidité du sol (4)A0–A3Les quatre premiers des 16 canaux analogiques
Capteur de gaz MQ-2A4Capteur à sortie analogique
Capteur de débit d'eau2Broche d'interruption externe pour ne pas manquer d'impulsions
Module relais 8 voies22–29Simples sorties numériques, sans besoin de PWM
Ventilateur (via MOSFET)6PWM pour régler la vitesse (Timer4)
Servo (trappe)8Le 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ômeCauseSolution
Le code ne se téléverse pas, erreur de délai avrdudeCarte restée sur Uno, mauvais port ou module branché sur les broches 0 et 1Choisis 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'UnoBranche SDA sur 20 et SCL sur 21
Le module SPI du shield ne fonctionne pasLe shield prend les signaux SPI sur les broches 11–13Utilise le connecteur ICSP ou les broches 50–52
analogWrite s'arrête sur 44–46 après ajout d'un servoLa bibliothèque Servo utilise Timer5Déplace la sortie PWM sur une broche entre 2 et 13
SoftwareSerial ne reçoit rienLa broche RX choisie ne gère pas les interruptions de changement de brocheUtilise les ports matériels Serial1, Serial2 ou Serial3
La carte chauffe ou redémarre toute seuleMoteur, bobine de relais ou nombreuses LED pilotés directement par les brochesUtilise un transistor, un MOSFET ou un driver de moteur, et ajoute une alimentation externe
Les valeurs analogiques fluctuent sans cesseLecture d'une entrée flottante ou fuite entre canauxNe lis que les canaux où un capteur est branché, et lis chaque canal deux fois en faisant la moyenne
Avant de commencer le projet, note le plan des broches sur papier : place d'abord les broches à fonction spéciale (ports série, I2C, SPI, interruptions et PWM), et répartis en dernier les simples broches numériques de 22 à 53. En suivant cet ordre, tu n'auras pas à débrancher des fils en plein projet. Pour comparer visuellement les broches, tu peux utiliser l'outil de brochage, et pour les lectures de capteurs bruitées, l'article filtrage des données de capteurs.

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.

Voir tous les projets
Chenillard à LED
AR-5Intermédiaire

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…

4.6(87)
217
Chenillard K2000 à LED
AR-6Intermédiaire

Chenillard K2000 à LED

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

4.8(107)
213
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

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…

4.6(50)
82
Horloge numérique avec afficheur 7 segments à 4 chiffres
AR-48Intermédiaire
Premium

Horloge numérique avec afficheur 7 segments à 4 chiffres

Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

4.8(56)
73
Serrure à code avec clavier 4x4 et écran LCD
AR-64Avancé
Premium

Serrure à code avec clavier 4x4 et écran LCD

Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

4.8(59)
75
Robot évitant les obstacles
AR-81Avancé
Premium

Robot évitant les obstacles

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

5.0(38)
49
Coffre-fort électronique intelligent
AR-92Avancé
Premium

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…

4.7(42)
63
Chorégraphie de servos en cercle - Motifs animés avec 32 servos
AR-97Avancé
Premium

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.

4.5(40)
62