Componenten · 11 min leestijd

Arduino Mega 2560-pinout: pinoverzicht, PWM, serieel en interrupts

Arduino Mega 2560-pinout in één gids: 54 digitale, 16 analoge en 15 PWM-pins, 4 hardware-seriële poorten en 6 interruptpins. Vergelijking met de Uno, voorbeeldcode en een 3D-printerbehuizing.

De Arduino Mega-pinout biedt de ruimste aansluitmogelijkheden van de Arduino-familie: de Arduino Mega 2560 heeft 54 digitale I/O-pins, 16 analoge ingangen, 15 PWM-uitgangen, 4 hardware-seriële poorten en 6 externe interruptpins. Als de Uno door zijn pins heen is, als je met meerdere seriële apparaten tegelijk moet praten (GPS, Bluetooth, GSM) of als je programmageheugen vol raakt, is de Mega het eerste board waar je aan denkt. Hij gebruikt bovendien dezelfde Arduino-taal, dezelfde IDE en de meeste van dezelfde bibliotheken als de Uno, dus je kunt opschalen zonder iets nieuws te leren.

In deze gids lopen we het pinoverzicht van de Mega groep voor groep door: welke pins PWM geven, welke pins elke seriële poort gebruikt, waar interrupts werken en waarom I2C en SPI op andere plekken zitten dan op de Uno. Daarna volgen een vergelijkingstabel met de Uno, wanneer je echt een Mega nodig hebt, waarom hij de standaard werd in 3D-printers en hoe je pins plant in een project met veel sensoren.

Arduino Mega 2560-board en pinheaders
Arduino Mega 2560: ATmega2560-processor, 54 digitale en 16 analoge pins; de dubbele header aan de rechterrand bevat digitale pins 22–53.

Wat is de Arduino Mega 2560 en hoe werkt hij?

De Arduino Mega 2560 is een ontwikkelboard rond de 8-bit ATmega2560-microcontroller. Hij draait op dezelfde klokfrequentie van 16 MHz als de Uno, gebruikt hetzelfde 5 V-logische niveau en wordt geprogrammeerd met dezelfde Arduino IDE; de Mega is dus niet sneller dan de Uno, maar breder. Dankzij de behuizing met 100 pinnen kunnen 70 signaalpins op het board worden uitgevoerd. USB wordt afgehandeld door de ATmega16U2-chip op het board; clone-boards gebruiken hiervoor meestal een CH340. Je kunt het board voeden met 5 V via USB, of met 7–12 V via de voedingsconnector en Vin; de onboard spanningsregelaar brengt die spanning terug naar 5 V. Het programmageheugen is 8 keer zo groot als dat van de Uno en het RAM 4 keer, dus grote bibliotheken, grafische displays en lange menu's draaien probleemloos op de Mega. De linkerhelft van het board heeft dezelfde pinindeling als de Uno, dus de meeste Uno-shields passen direct op de Mega.

EigenschapWaarde
MicrocontrollerATmega2560 (8-bit AVR)
Klokfrequentie16 MHz
Flashgeheugen256 KB (8 KB gebruikt door de bootloader)
SRAM8 KB
EEPROM4 KB
Werkspanning5 V
Ingangsspanning (connector / Vin)7–12 V aanbevolen, 6–20 V limiet
Digitale I/O54 (waarvan 15 PWM)
Analoge ingangen16 (A0–A15, 10-bit)
Hardware-seriële poorten4 (Serial, Serial1, Serial2, Serial3)
Externe interruptpins6
Stroom per pin20 mA aanbevolen, 40 mA absoluut maximum
Stroom van de 3.3V-pin50 mA maximum
Afmetingen101,5 × 53,3 mm

Vergelijking Arduino Mega en Uno

EigenschapArduino Uno R3Arduino Mega 2560
MicrocontrollerATmega328PATmega2560
Klokfrequentie16 MHz16 MHz
Digitale pins1454
PWM-pins6 (3, 5, 6, 9, 10, 11)15 (2–13, 44, 45, 46)
Analoge ingangen6 (A0–A5)16 (A0–A15)
Hardware-seriële poorten14
Externe interruptpins2 (2, 3)6 (2, 3, 18, 19, 20, 21)
Flash / SRAM / EEPROM32 KB / 2 KB / 1 KB256 KB / 8 KB / 4 KB
I2C-pinsA4 (SDA), A5 (SCL)20 (SDA), 21 (SCL)
SPI-pins10, 11, 12, 1353, 51, 50, 52
Afmetingen68,6 × 53,4 mm101,5 × 53,3 mm

Arduino Mega-pinoverzicht: alle pingroepen

PingroepPinnummersFunctie en opmerkingen
Digitale pins gedeeld met de Uno0–130 (RX0) en 1 (TX0) vormen de USB-seriële lijn; pin 13 heeft de onboard led
Pins voor extra seriële poorten14–1914 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1
I2C20 (SDA), 21 (SCL)Wire-bibliotheek; het board heeft 10 kΩ pull-upweerstanden naar 5 V
Digitale header met dubbele rij22–53Algemene in-/uitgang; geen PWM behalve 44, 45 en 46
PWM2–13, 44, 45, 46Gebruikt met analogWrite(pin, 0–255)
SPI50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)Dezelfde signalen zitten ook op de ICSP-header
Analoge ingangenA0–A15 (digitaal 54–69)Uitlezen met analogRead; ook te gebruiken als digitale pins
Voeding en besturing5V, 3.3V, Vin, GND, IOREF, AREF, RESETAREF is de externe analoge referentie-ingang; als je RESET LOW trekt, herstart het board
Elke I/O-pin van de Mega kan maximaal 40 mA aan; blijf voor veilig gebruik onder 20 mA. De totale stroom die de processor over alle pins kan leveren is ongeveer 200 mA. Dat er 54 pins zijn, betekent niet dat je 54 leds tegelijk direct kunt aansturen, of een motor of relaisspoel op een pin kunt aansluiten; dat beschadigt de processor. Gebruik voor zulke belastingen een transistor of een driver. Pins 0 en 1 zijn bovendien verbonden met de USB-seriële lijn, dus het uploaden van code kan mislukken als er een module op zit aangesloten.

PWM-pins en timers

De Mega heeft 15 PWM-uitgangen: de 12 pins van 2 tot en met 13, plus 44, 45 en 46. Met deze pins stel je ledhelderheid en motortoerental in met analogWrite(pin, 0–255). PWM-signalen komen van zes hardwaretimers (Timer0–Timer5); Timer0 en Timer2 zijn 8-bit, de rest is 16-bit. Omdat Timer0 ook millis() en delay() aanstuurt, draaien pins 4 en 13 op ongeveer 980 Hz en de overige PWM-pins op ongeveer 490 Hz. Let vooral hierop: als een bibliotheek een timer overneemt, werkt PWM op de pins van die timer niet meer. Op de Mega gebruikt de Servo-bibliotheek Timer5 voor de eerste 12 servo's, dus zodra je een servo aansluit, werkt analogWrite niet meer op 44, 45 en 46; tone() gebruikt Timer2 en beïnvloedt pins 9 en 10. Duty cycle en frequentie worden uitgebreid uitgelegd in Wat is PWM?.

TimerPWM-pinsStandaardfrequentieWaarmee botst het?
Timer0 (8-bit)4, 13~980 Hzmillis() en delay()
Timer1 (16-bit)11, 12~490 HzServo-bibliotheek (servo's 13–24)
Timer2 (8-bit)9, 10~490 Hztone()-functie
Timer3 (16-bit)2, 3, 5~490 HzServo-bibliotheek (servo's 25–36)
Timer4 (16-bit)6, 7, 8~490 HzServo-bibliotheek (servo's 37–48)
Timer5 (16-bit)44, 45, 46~490 HzServo-bibliotheek (eerste 12 servo's)

4 hardware-seriële poorten: Serial, Serial1, Serial2, Serial3

De Uno heeft maar één hardware-seriële poort, en die wordt gedeeld met USB; voor een tweede apparaat ben je gedwongen SoftwareSerial te gebruiken. SoftwareSerial kan bij hoge snelheden data verliezen, kan maar naar één poort tegelijk luisteren en vertraagt de rest van je code doordat het interrupts uitschakelt tijdens het ontvangen van bytes. De Mega heeft vier onafhankelijke UART-eenheden; elk werkt op de achtergrond met een eigen ontvangstbuffer van 64 bytes, zodat binnenkomende data niet verloren gaat terwijl je in loop() met ander werk bezig bent. De bedradingsregel is voor elke poort hetzelfde: de TX van de module gaat naar de RX van de Mega, de RX van de module naar de TX van de Mega, en de massa's moeten altijd gemeenschappelijk zijn. Als je de 5 V-TX-uitgang van de Mega aansluit op de RX-ingang van een module met 3,3 V-logica, breng het signaal dan terug naar ongeveer 3,3 V met een spanningsdeler van 1 kΩ en 2 kΩ. De bridge-code hieronder stuurt alles wat je in de Serial Monitor typt door naar Serial1 en alles wat van Serial1 komt terug naar de Serial Monitor; het is de snelste manier om modules zoals de HC-05 te testen. Voor de werking van UART, zie het artikel UART seriële communicatie.

PortTX-pinRX-pinTypisch gebruik
Serial10USB en Serial Monitor
Serial11819HC-05 Bluetooth-module
Serial21617NEO-6M GPS-module
Serial31415SIM800L GSM of vingerafdruksensor
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}

Interruptpins

Met een externe interrupt vang je een verandering op een pin binnen microseconden op, wat loop() op dat moment ook doet; ideaal voor encoders, waterdebietsensoren, toerentellers en knoppen die snel moeten reageren. De Mega heeft 6 pins die je met attachInterrupt kunt gebruiken: 2, 3, 18, 19, 20 en 21. Interruptnummers volgen de pinvolgorde niet (2 → 0, 3 → 1, 21 → 2, 20 → 3, 19 → 4, 18 → 5); typ het nummer dus niet met de hand, maar gebruik altijd digitalPinToInterrupt(pin). Let op: 18 en 19 zijn de pins van Serial1 en 20 en 21 zijn de I2C-pins; als je Serial1 en I2C gebruikt, blijven alleen 2 en 3 over. Heb je meer pins nodig, dan werken de pin change interrupts (PCINT) van de ATmega2560 op pins 10–15, 50–53 en A8–A15 en kun je ze gebruiken met geschikte bibliotheken. De code hieronder telt pulsen op pins 2 en 18; de interruptfuncties blijven kort, de gedeelde tellers zijn als volatile gedeclareerd en interrupts worden tijdens het uitlezen kort gepauzeerd. Omdat in dit voorbeeld 18 voor de interrupt wordt gebruikt, kun je Serial1 niet gebruiken. Wil je dieper graven, lees dan het artikel 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 analoge ingangen (A0–A15)

De 16 analoge ingangen van de Mega delen via een multiplexer één 10-bit ADC. Elke meting levert een waarde tussen 0 en 1023; met een referentie van 5 V is één stap ongeveer 4,9 mV. Een omzetting duurt ongeveer 100 microseconden, dus je kunt zo'n 10.000 metingen per seconde doen, waardoor het achter elkaar scannen van 16 kanalen geen enkel probleem is. Heb je nauwkeurigere metingen nodig, dan kun je met analogReference de interne referentie van 1,1 V (INTERNAL1V1) of 2,56 V (INTERNAL2V56) kiezen; de INTERNAL-optie van de Uno bestaat niet op de Mega. Analoge pins kunnen ook als digitale pins worden gebruikt: A0 is digitale pin 54 en A15 is digitale pin 69, dus je kunt een led op die pin laten branden met pinMode(A8, OUTPUT). Bij snel wisselen tussen kanalen kan de spanning van het vorige kanaal in de volgende meting doorsijpelen; bij bronnen met een inwendige weerstand boven 10 kΩ verkleint het twee keer uitlezen van elk kanaal en het weggooien van de eerste waarde deze fout. Hoe de ADC werkt, lees je in het artikel analoog-digitaalomzetting.

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}

I2C- en SPI-pins: compatibiliteit met Uno-shields

Het verschil waar mensen die naar de Mega overstappen het vaakst over struikelen, is de plek van de communicatiepins. Op de Uno zit I2C op A4 en A5 en SPI op pins 10–13, terwijl I2C op de Mega op 20 (SDA) en 21 (SCL) zit en SPI op pins 50–53. Op R3-boards worden SDA en SCL herhaald op de header naast AREF; de SPI-signalen zitten op dezelfde plek op de 6-pins ICSP-header in het midden van beide boards. Daarom werken shields die SPI van de ICSP-header halen prima op de Mega, terwijl oudere shields die SPI rechtstreeks van 11–13 halen dat niet doen. De Wire- en SPI-bibliotheken gebruiken zelf de juiste pins; jouw taak is de draden op de juiste plekken te steken. Voor SPI kun je de CS-pin van een apparaat op elke digitale pin aansluiten die je wilt, maar maak van pin 53 nooit een ingang: als deze pin een ingang wordt en LOW wordt getrokken, schakelt de processor op SPI over naar slave-modus en stopt de communicatie. Een RC522 RFID-lezer sluit je bijvoorbeeld aan als SDA → 53, SCK → 52, MOSI → 51, MISO → 50. Voor de details van de protocollen, zie Wat is I2C? en Wat is SPI?.

SignaalArduino UnoArduino MegaESP32Raspberry Pi Pico
I2C SDAA420GPIO 21GP4
I2C SCLA521GPIO 22GP5
SPI MISO1250GPIO 19GP16
SPI MOSI1151GPIO 23GP19
SPI SCK1352GPIO 18GP18
SPI SS / CS1053GPIO 5GP17
TX / RX van extra seriële poortenGeen (SoftwareSerial)18 / 19 (Serial1)GPIO 17 / 16 (Serial2)GP0 / GP1 (UART0)
Logisch niveau5 V5 V3,3 V3,3 V

Stap voor stap: je eerste Mega-programma (looplicht met 16 leds)

  1. Sluit de Mega met een USB-B-kabel aan op je computer; als de USB-chip van je clone-board een CH340 is, installeer dan eerst het stuurprogramma.
  2. Kies in de Arduino IDE in het menu Tools › Board de optie Arduino Mega or Mega 2560 en laat Processor op ATmega2560 (Mega 2560) staan.
  3. Kies de poort van het board in het menu Tools › Port (zoiets als COM3 op Windows, een naam die begint met /dev/cu.usbmodem of /dev/cu.wchusbserial op macOS).
  4. Sluit 16 leds aan op pins 22–37, elk via een weerstand van 220 Ω, en verbind de korte pootjes (kathodes) van de leds met de GND-rail. Een rode led trekt (5 − 2) / 220 ≈ 13,6 mA; voor andere kleuren kun je de ledweerstandcalculator gebruiken.
  5. Upload de code hieronder; de leds lopen achter elkaar aan. Omdat er steeds maar één led brandt, blijft de totale stroom onder 20 mA. Het heen-en-weer-effect vind je in het artikel Knight Rider en looplicht.
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}

Wanneer heb je een Arduino Mega nodig?

  • Als je pins tekortkomt: alleen al een 4x4-toetsenbord heeft 8 pins nodig en een parallelle LCD 6; voeg daar relais, knoppen en sensoren aan toe en de 20 pins van de Uno zijn snel op.
  • Als je meerdere seriële apparaten hebt: tegelijk naar een GPS, Bluetooth en GSM luisteren is op de Uno bijna onmogelijk, terwijl ze op de Mega elk een eigen hardwarepoort krijgen.
  • Als het geheugen vol raakt: als de compiler waarschuwt voor weinig geheugen, of als je een TFT-display, SD-kaart en menucode combineert, geven 256 KB flash en 8 KB RAM je veel ruimte; details in het artikel Arduino heeft te weinig geheugen.
  • Als je veel analoge sensoren hebt: met 16 kanalen lees je bodemvocht, gas, licht en potmeters uit zonder multiplexer.
  • Voor robots met veel servo's: de Servo-bibliotheek ondersteunt op de Mega tot 48 servo's (12 op de Uno); geschikt voor een robotarm en lopende robots.
  • Wanneer je geen Mega nodig hebt: als je Wi-Fi, hoge snelheid of laag verbruik nodig hebt, is de ESP32 verstandiger (Arduino of ESP32?); als je maar een paar uitgangen tekortkomt, is het uitbreiden van de pins van de Uno met een 74HC595-schuifregister een goedkopere en kleinere oplossing.

Arduino Mega en RAMPS 1.4 in 3D-printers

Jarenlang draaiden de meeste doe-het-zelf-3D-printers en kleine CNC-machines op een Arduino Mega met een RAMPS 1.4-board erbovenop; dit duo is nog steeds de meest voorkomende printerelektronica voor educatief gebruik. De reden is simpel: printerfirmware zoals Marlin is met display- en SD-kaartondersteuning al snel groter dan 100 KB; vijf stappenmotordrivers (X, Y, Z en twee extruders), drie MOSFET-uitgangen, zes eindschakelaars, thermistors, een LCD en een SD-kaart hebben ook tientallen pins nodig. Op RAMPS zijn de step- en richtingssignalen van de X-as verbonden met 54 en 55 (A0 en A1), die van de Y-as met 60 en 61 (A6 en A7), die van de Z-as met 46 en 48 en die van de eerste extruder met 26 en 28. De nozzleverwarming wordt aangestuurd vanaf PWM-pin 10, de bedverwarming vanaf 8 en de ventilator vanaf 9; de thermistors van nozzle en bed worden uitgelezen op A13 en A14. Deze indeling is ook een mooi voorbeeld van hoe je analoge pins efficiënt als digitale uitgangen kunt inzetten. Voor stroominstelling en microstepping van de stappenmotordrivers, zie het artikel A4988-stappenmotordriver.

Voorbeeldproject met meerdere sensoren: je pins goed plannen

ModuleMega-pinWaarom deze pin?
HC-05 Bluetooth18 (TX1), 19 (RX1)De communicatie met de telefoon loopt via een hardware-seriële poort, zodat er geen data verloren gaat
NEO-6M GPS16 (TX2), 17 (RX2)Een GPS stuurt elke seconde veel regels en heeft een eigen poort nodig
SIM800L GSM14 (TX3), 15 (RX3)De derde onafhankelijke poort voor sms en gesprekken
I2C LCD + BME28020 (SDA), 21 (SCL)Twee apparaten delen dezelfde I2C-lijn met verschillende adressen
RC522 RFID50, 51, 52, 53 + RST 49Hardware-SPI-bus, met 53 als CS
Bodemvochtsensoren (4)A0–A3De eerste vier van de 16 analoge kanalen
MQ-2-gassensorA4Sensor met een analoge uitgang
Waterdebietsensor2Externe interruptpin, zodat er geen pulsen worden gemist
8-kanaals relaismodule22–29Gewone digitale uitgangen die geen PWM nodig hebben
Ventilator (via MOSFET)6PWM voor toerentalregeling (Timer4)
Servo (luik)8Een servosignaal kan van elke digitale pin komen; omdat Timer5 wordt gebruikt, kunnen 44–46 niet voor PWM worden gebruikt

Veelgemaakte fouten en hoe je ze oplost

SymptoomOorzaakOplossing
Code wordt niet geüpload, avrdude-timeoutfoutHet board staat nog op Uno, de poort is verkeerd of er zit een module op pins 0 en 1Kies Mega 2560 en de juiste poort in het menu Tools en haal tijdens het uploaden de draden op 0 en 1 los
I2C-display of -sensor wordt niet gevondenUit Uno-gewoonte zijn de draden in A4 en A5 gestokenSluit SDA aan op 20 en SCL op 21
SPI-module op een shield werkt nietDe shield haalt zijn SPI-signalen van pins 11–13Gebruik de ICSP-header of pins 50–52
analogWrite werkt na het toevoegen van een servo niet meer op 44–46De Servo-bibliotheek gebruikt Timer5Verplaats de PWM-uitgang naar een pin tussen 2 en 13
SoftwareSerial ontvangt geen dataDe gekozen RX-pin ondersteunt geen pin change interruptsGebruik de hardwarepoorten Serial1, Serial2 of Serial3
Het board wordt heet of reset zichzelfEen motor, relaisspoel of veel leds worden direct vanaf de pins aangestuurdGebruik een transistor, MOSFET of motordriver en voeg een externe voeding toe
Analoge waarden blijven schommelenUitlezen van een zwevende ingang of lekkage tussen kanalenLees alleen de kanalen uit waarop een sensor is aangesloten, en lees elk kanaal twee keer uit en neem het gemiddelde
Schrijf je pinplan op papier voordat je met het project begint: plaats eerst de pins met een speciale functie (seriële poorten, I2C, SPI, interrupts en PWM) en deel de gewone digitale pins tussen 22 en 53 als laatste uit. Als je in deze volgorde werkt, hoef je halverwege het project geen draden los te trekken. Om pins visueel te vergelijken gebruik je de pinouttool, en voor ruizige sensormetingen het artikel filteren van sensordata.

De Arduino Mega is de makkelijkste stap omhoog voor iedereen die de Uno kent: dezelfde code, dezelfde bibliotheken, maar veel meer pins, poorten en geheugen. De gidsen Arduino Uno-pinout en Arduino Nano-pinout komen ook van pas bij kleinere projecten. In de BlueGrays-app werk je stap voor stap pinhongerige projecten door, zoals een digitale klok met 4 zevensegmentcijfers, een codeslot met toetsenbord en LCD, een robot die obstakels ontwijkt en een slimme elektronische kluis, met schakelschema's en code, en kun je de pinindeling aanpassen aan je eigen Mega.

Veelgestelde vragen

Hoeveel pins heeft de Arduino Mega?

De Arduino Mega 2560 heeft in totaal 70 signaalpins: 54 digitale I/O en 16 analoge ingangen. 15 van de digitale pins geven PWM-uitgang, en de analoge pins (A0–A15) kunnen indien nodig ook als digitale pins 54–69 worden gebruikt. Daarnaast zijn er voedings- en besturingspins zoals 5V, 3.3V, Vin, GND, AREF, IOREF en RESET.

Welke pins zijn de PWM-pins van de Arduino Mega?

Op de Mega geven pins 2 tot en met 13 en pins 44, 45 en 46 PWM, samen 15 PWM-uitgangen. Pins 4 en 13 draaien op ongeveer 980 Hz en de rest op ongeveer 490 Hz. Als de Servo-bibliotheek wordt gebruikt, is PWM op 44, 45 en 46 uitgeschakeld.

Waar zitten de SDA- en SCL-pins van de Arduino Mega?

Op de Mega zit de I2C-bus op pins 20 (SDA) en 21 (SCL); op R3-boards staan dezelfde signalen ook op de header naast AREF. A4 en A5 zijn op de Mega gewone analoge ingangen, geen I2C zoals op de Uno. SPI zit op pins 50 (MISO), 51 (MOSI), 52 (SCK) en 53 (SS) en op de ICSP-header.

Werkt Arduino Uno-code op de Mega?

De meeste Uno-code compileert en draait zonder wijzigingen op de Mega; je hoeft alleen Mega 2560 als board te kiezen in het menu Tools. Problemen zitten meestal aan de hardwarekant: de I2C- en SPI-pins zitten op andere plekken en code die direct timer- en poortregisters aanspreekt, moet worden aangepast. Code die SoftwareSerial gebruikt naar de hardware-seriële poorten van de Mega verplaatsen geeft ook betrouwbaardere resultaten.

Welke pins zijn de interruptpins van de Arduino Mega?

De externe interruptpins die je met attachInterrupt kunt gebruiken zijn 2, 3, 18, 19, 20 en 21. Omdat 18 en 19 gedeeld worden met Serial1 en 20 en 21 met I2C, blijven alleen 2 en 3 vrij als je die bussen gebruikt. Met digitalPinToInterrupt(pin) in plaats van het interruptnummer met de hand te typen voorkom je fouten.

Kan ik een 3,3 V-sensor op de Arduino Mega aansluiten?

Ja, maar het vraagt zorg. De Mega werkt met 5 V-logica; een 3,3 V-uitgang leest hij meestal als HIGH, maar de 5 V-uitgang van de Mega kan een 3,3 V-ingang beschadigen. Gebruik dus een spanningsdeler of een niveauconverter op de ingangspins van de module; kies voor I2C vanwege de 5 V-pull-upweerstanden op het board liever een bidirectionele niveauconverter.

Alle projecten bekijken
LED-looplicht
AR-5Gemiddeld

LED-looplicht

Lichten die na elkaar aangaan, alsof ze rennen. De Arduino laat zes LED's een voor een branden; elke LED licht even op en gaat uit, zodat het licht van begin tot eind loopt en dan opnieuw begint.

4.6(87)
218
Knight Rider-ledeffect
AR-6Gemiddeld

Knight Rider-ledeffect

Het klassieke scannerlicht: een lichtpunt schuift van het ene uiteinde van zes LED's naar het andere en komt dan terug.

4.8(107)
214
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
Digitale klok met 7-segmentdisplay met 4 cijfers
AR-48Gemiddeld
Premium

Digitale klok met 7-segmentdisplay met 4 cijfers

Een lichtgevende digitale klok met vier cijfers, zoals op een keukenoven. De DS1302-klokmodule houdt de tijd bij en de Arduino leest elke seconde uren en minuten uit en toont ze op het display met…

4.8(56)
73
Codeslot met 4x4-keypad en LCD
AR-64Gevorderd
Premium

Codeslot met 4x4-keypad en LCD

Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

4.8(59)
75
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
Slimme elektronische kluis
AR-92Gevorderd
Premium

Slimme elektronische kluis

Een kleine kluis voor je waardevolle spullen die opent met een code. Je tikt je viercijferige code in op het toetsenbord; klopt hij, dan opent de servomotor het slot, gaat het groene lampje aan en…

4.7(42)
63
Servocirkelchoreografie: geanimeerde patronen met 32 servo's
AR-97Gevorderd
Premium

Servocirkelchoreografie: geanimeerde patronen met 32 servo's

Een visueel animatieproject met 32 servomotoren in een cirkel op een Arduino Mega. De servo's worden in één array beheerd, zijn aangesloten op pin 22–53 van de Mega en voeren vier bewegingsreeksen uit: een chaotische trilling met willekeurige hoeken, een gesynchroniseerde zwaai, een golf die rond de cirkel loopt en een kompasnaald die heen en weer zwaait.

4.5(40)
62