Arduino Pro Mini: Programmieren, Pinbelegung und Stromsparen
Arduino Pro Mini erklärt: 3,3 V oder 5 V, Programmieren per USB-TTL, Pinbelegung, µA-Schlaf mit LowPower, Batterie-Funksensor mit nRF24 und Vergleich mit Nano.
Der Arduino Pro Mini ist ein Arduino-Board mit demselben ATmega328P wie der Arduino Uno, misst aber nur 18 × 33 mm und hat keine USB-Buchse. Es gibt ihn in zwei Versionen, 3,3 V / 8 MHz und 5 V / 16 MHz, programmiert wird er mit einem USB-TTL-Adapter. Seine kleine Bauform, der niedrige Preis und ein Schlafstrom, der bei richtiger Vorbereitung auf wenige Mikroampere sinkt, machen ihn zum Lieblingsboard für Funksensoren, die monate- oder sogar jahrelang mit Batterien laufen, für Wearables und für fest eingebaute Schaltungen.
In dieser Anleitung lernst du den Unterschied zwischen beiden Versionen und wie du erkennst, welche du hast, die Pinbelegung, die Versorgungspins RAW und VCC sowie das Programmieren mit USB-TTL-Adapter und automatischem Reset über DTR. Danach schickst du das Board mit der LowPower-Bibliothek schlafen, senkst den Verbrauch durch Auslöten von Power-LED und Spannungsregler von Milliampere auf Mikroampere und baust einen batteriebetriebenen Sensorknoten, der die gemessene Temperatur per nRF24L01 sendet. Zum Schluss vergleichst du den Pro Mini mit dem Arduino Nano und siehst, wann welcher die bessere Wahl ist.

Was ist der Arduino Pro Mini? Die 3,3-V- und 5-V-Version
Ursprünglich hat SparkFun den Pro Mini entworfen; die meisten Boards im Handel sind heute Klone desselben offenen Designs. Auf dem Board sitzen der ATmega328P als Herz des Uno, ein Quarz, ein kleiner Spannungsregler, zwei LEDs und ein Reset-Taster; USB-Chip, USB-Buchse und große Stromversorgung fehlen. Fast jeder Code, den du für den Uno schreibst, läuft unverändert. Die eigentliche Wahl ist die Betriebsspannung. Der ATmega328P braucht für zuverlässige 16 MHz etwa 3,8 V oder mehr; deshalb hat die 3,3-V-Version einen 8-MHz-Quarz und läuft mit halber Geschwindigkeit. Dafür spricht sie ohne Pegelwandler mit 3,3-V-Modulen wie nRF24L01, BME280 oder SD-Karte und lässt sich direkt aus einer Batterie versorgen.
| Merkmal | 3,3-V-/8-MHz-Version | 5-V-/16-MHz-Version |
|---|---|---|
| Prozessor | ATmega328P | ATmega328P |
| Taktfrequenz | 8 MHz | 16 MHz |
| Logikpegel und VCC | 3,3 V | 5 V |
| RAW-Eingang | 3,35–12 V | 5–12 V |
| Programmspeicher | 32 KB (30 KB nutzbar, 2 KB Bootloader) | 32 KB (30 KB nutzbar) |
| SRAM / EEPROM | 2 KB / 1 KB | 2 KB / 1 KB |
| Digitale Pins / PWM | 14 / 6 | 14 / 6 |
| Analogeingänge | 8 (A0–A7) | 8 (A0–A7) |
| Upload-Geschwindigkeit | 57600 Baud | 57600 Baud |
| Aufdruck auf dem Quarz | 8.000 | 16.000 |
| Ideal für | Batteriesensoren, 3,3-V-Module | 5-V-Sensoren, Relais- und LED-Treiber, zeitkritische Aufgaben |
Arduino Pro Mini Pinbelegung
Der Pro Mini hat an jeder langen Kante 12 Pins und an der kurzen Kante den sechspoligen Programmieranschluss. Die Pinnummern entsprechen genau denen des Uno, du kannst ein Projekt also auf dem Uno testen und mit demselben Code auf den Pro Mini übertragen. Der einzige Unterschied: A4, A5, A6 und A7 liegen nicht am Rand, sondern in eigenen Löchern im Inneren des Boards. Was an welchem Pin liegt, siehst du auch schnell im Pinbelegungs-Werkzeug.
| Pin | Funktion | Hinweis |
|---|---|---|
| D0 (RXI), D1 (TXO) | Serielle Schnittstelle (UART) | Mit dem Programmieranschluss verbunden; Module an diesen Pins beim Hochladen abklemmen |
| D2, D3 | Externer Interrupt (INT0, INT1) | Die besten Pins zum Aufwecken aus dem Schlaf |
| D3, D5, D6, D9, D10, D11 | PWM (analogWrite) | Wie beim Uno |
| D10, D11, D12, D13 | SPI (SS, MOSI, MISO, SCK) | nRF24L01, SD-Karte, TFT-Display |
| D13 | Onboard-LED | Teilt sich die Leitung mit dem SPI-Takt; bei SPI flackert die LED |
| A0–A3 | Analogeingang oder Digitalpin | An der langen Kante |
| A4 (SDA), A5 (SCL) | I2C | Im Inneren des Boards; bei Klonen kann die Lage abweichen |
| A6, A7 | Nur Analogeingang | pinMode und digitalRead funktionieren hier nicht |
| RAW | Reglereingang | Hier kommen Batterie oder Netzteil an |
| VCC | Geregelte 3,3 V oder 5 V | Ausgang des Reglers; kann auch direkt aus einer geregelten Quelle versorgt werden |
| RST | Reset | Auf GND gezogen startet das Board neu |
| BLK, GND, VCC, RXI, TXO, GRN | Programmieranschluss | BLK = GND, GRN = DTR (Auto-Reset) |
Stromversorgung: RAW, VCC und der Spannungsregler
Den Pro Mini kannst du auf zwei Arten versorgen. Schließt du eine ungeregelte Quelle (9-V-Block, 3 AA-Zellen oder einen 7,4-V-Akku) an RAW an, setzt der kleine Regler auf dem Board sie auf 3,3 V oder 5 V herab. Hast du schon eine geregelte Spannung, etwa den Ausgang des USB-TTL-Adapters oder 2 AA-Zellen, gibst du sie direkt auf VCC, und der Regler wird umgangen. Der Onboard-Regler ist meist ein kleiner LDO für etwa 150 mA (beim Original ein MIC5205, bei Klonen ähnliche Typen). Das reicht für das Board und ein paar Sensoren, aber Servos, lange LED-Streifen oder WLAN-Module solltest du nicht darüber versorgen.
| Quelle | Anschluss | Hinweis |
|---|---|---|
| 9-V-Block oder 7–12-V-Netzteil | RAW | Der Regler verheizt den Überschuss; bei 12 V und höherem Strom wird er warm |
| 2S-Li-Ionen-Akku (7,4 V) | RAW | Für beide Versionen geeignet |
| Einzelne Li-Ionen-Zelle (3,0–4,2 V) | RAW (3,3-V-Version) | Reicht für die 5-V-Version nicht |
| 2 AA-Zellen (2,4–3,2 V) | VCC (3,3-V-Version) | Umgeht den Regler; ideal für minimalen Verbrauch |
| USB-TTL-Adapter | VCC | Beim Programmieren; 3,3 V oder 5 V passend zur Version wählen |
| Fertige 5 V (USB-Ladegerät, Powerbank) | VCC (5-V-Version) | An RAW reicht die Spannungsreserve des Reglers nicht |
Programmieren mit USB-TTL-Adapter und DTR-Reset

Da kein USB-Chip vorhanden ist, brauchst du zum Hochladen einen externen USB-TTL-Adapter (CH340, CP2102 oder FT232). Beim Hochladen muss das Board zurückgesetzt werden, denn der Bootloader nimmt ein neues Programm nur kurz nach dem Start an. Verbindest du den DTR-Pin des Adapters mit dem GRN-Pin des Pro Mini, macht der 100-nF-Kondensator auf dem Board aus der fallenden DTR-Flanke einen kurzen Reset-Impuls, und der Upload klappt ohne Tastendruck. Oft passt die Pinreihenfolge so, dass sich der Adapter direkt auf den Anschluss an der kurzen Kante stecken lässt, aber vergleiche vorher unbedingt die Beschriftungen.
| USB-TTL | Pro Mini | Hinweis |
|---|---|---|
| GND | GND / BLK | Gemeinsame Masse |
| VCC (3,3 V oder 5 V) | VCC | Jumper passend zur Board-Version setzen |
| TXD | RXI | Über Kreuz |
| RXD | TXO | Über Kreuz |
| DTR | GRN | Auto-Reset |
- Wähle in der Arduino IDE Werkzeuge > Board > Arduino AVR Boards > Arduino Pro or Pro Mini.
- Unter Werkzeuge > Prozessor wählst du die passende Option: ATmega328P (3.3V, 8 MHz) oder ATmega328P (5V, 16 MHz).
- Unter Werkzeuge > Port wählst du den Port des Adapters (unter Windows z. B. COM3, unter macOS /dev/cu.usbserial... oder /dev/cu.wchusbserial...).
- Öffne Datei > Beispiele > 01.Basics > Blink und klicke auf Hochladen. Die LED an D13 sollte im Sekundentakt blinken.
- Wechselt die LED nur alle zwei Sekunden, hast du ein 8-MHz-Board mit der 16-MHz-Option bespielt; wechselt sie jede halbe Sekunde, ist es umgekehrt. Korrigiere den Prozessor und lade erneut hoch.
Hat dein Adapter keinen DTR-Pin, timst du den Upload von Hand: Sobald die IDE fertig kompiliert hat und im Ausgabefenster "Uploading..." erscheint, drückst du kurz den Reset-Taster des Pro Mini. Hast du gar keinen Adapter, kann vorübergehend ein Arduino Uno einspringen: Verbinde RESET des Uno mit GND, Pin 0 (RX) des Uno mit RXI und Pin 1 (TX) mit TXO des Pro Mini. Hier wird gerade und nicht über Kreuz verbunden, weil der USB-Chip des Uno die Übersetzung schon übernimmt. Bekommst du beim Hochladen den Fehler "stk500_getsync(): not in sync", findest du Lösungen im Artikel Arduino Sketch lässt sich nicht hochladen.
Stromsparen: Schlafmodus und die LowPower-Bibliothek
Ein Sensor misst meist alle fünf Minuten und tut in mehr als 99 % der Zeit dazwischen nichts. Mit delay() zu warten lässt den Prozessor mit voller Geschwindigkeit weiterlaufen; ein 3,3-V-Pro-Mini zieht dabei einige Milliampere. Der tiefste Schlafmodus des ATmega328P heißt Power-down: Der Takt steht, nur Watchdog-Timer und externe Interrupts arbeiten weiter, und der Verbrauch des Chips sinkt in den Mikroampere-Bereich. Die Bibliothek Low-Power von Rocket Scream (im Bibliotheksverwalter nach "Low-Power" suchen) packt die komplizierten Registereinstellungen in eine einzige Zeile. Der Watchdog zählt höchstens 8 Sekunden, längere Pausen entstehen deshalb in einer Schleife; aufwecken kann das Board auch ein Taster oder Sensor an D2 oder D3.
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() erwartet drei Parameter. Der erste ist die Schlafdauer: von SLEEP_15MS bis SLEEP_8S, dazu SLEEP_FOREVER, wenn nur ein Interrupt wecken soll. Der Watchdog-Oszillator ist nicht so genau wie ein Quarz, ein 8-Sekunden-Schlaf kann je nach Temperatur und Spannung um etwa 10 % abweichen; brauchst du genaue Zeiten, weckst du besser über den Alarmausgang eines RTC-Moduls. Der zweite Parameter schaltet den ADC im Schlaf ab. Der dritte deaktiviert im Schlaf die Unterspannungserkennung (BOD) und spart so noch etwa 20 µA. Mit attachInterrupt wird über D2 und D3 geweckt (andere Pins brauchen einen Pin-Change-Interrupt); im Power-down-Modus reagieren diese beiden Pins nur auf LOW-Pegel, deshalb nutzt der Code LOW und trennt den Interrupt gleich nach dem Aufwachen.
Mit ausgelöteter LED und ausgelötetem Regler auf Mikroampere kommen
Im Schlaf zieht der Prozessor fast nichts, trotzdem misst du noch 1–3 mA. Schuld sind zwei Bauteile auf dem Board: Die dauerhaft leuchtende Power-LED braucht allein 1–3 mA, und der Spannungsregler zieht selbst ohne Last Strom für seine interne Schaltung (bei Reglern vom Typ MIC5205 etwa 80 µA). Lötest du beide aus, sinkt der Pro Mini mit laufendem Watchdog auf etwa 4–5 µA und unter 1 µA, wenn er nur auf einen externen Interrupt wartet. Die Tabelle zeigt typische Werte für ein 3,3-V-/8-MHz-Board und die theoretische Laufzeit mit den rund 2000 mAh, die zwei AA-Zellen liefern. Mit eigenen Werten rechnest du im Akkulaufzeit-Rechner.
| Zustand (3,3 V / 8 MHz) | Ungefährer Strom | Theoretische Laufzeit mit 2000 mAh |
|---|---|---|
| Schläft nie, wartet mit delay() | 4–5 mA | Etwa 17–21 Tage |
| Schlaf mit LowPower, Board unverändert | 1–3 mA | Etwa 1–3 Monate |
| Power-LED ausgelötet | Etwa 80–100 µA (je nach Regler) | Etwa 2–3 Jahre |
| LED und Regler ausgelötet, 8 s Watchdog-Schlaf | Etwa 4–5 µA | Rechnerisch über 40 Jahre; praktisch begrenzt die Selbstentladung |
| LED und Regler ausgelötet, SLEEP_FOREVER | Unter 1 µA | Begrenzt durch die Lagerfähigkeit der Batterie |
- Miss zuerst den Schlafstrom: Stelle das Multimeter auf den mA-Bereich und schalte es in Reihe zwischen Pluspol der Batterie und Versorgungspin des Boards. Sinkt der Wert unter 1 mA, wechsle in den µA-Bereich.
- Finde die Power-LED: Es ist die kleine LED, die immer leuchtet, solange das Board Strom hat (die LED an D13 ist die blinkende). Erhitze ihre beiden Enden abwechselnd mit dem Lötkolben und heb sie ab, oder entferne den Vorwiderstand daneben; auch das Durchtrennen der Leiterbahn mit einem Cuttermesser funktioniert.
- Finde den Regler: das kleine fünfbeinige SOT-23-Bauteil nahe am RAW-Pin. Gib reichlich Lötzinn auf die Beinchen und erhitze alle gleichzeitig, um ihn abzuheben.
- Nach dem Entfernen des Reglers funktioniert RAW nicht mehr. Versorge das Board direkt über VCC, bei der 3,3-V-Version mit 1,8–3,6 V: zwei AA-Zellen, eine LiFePO4-Zelle oder eine Li-Ionen-Zelle hinter einem Regler mit wenigen Mikroampere Ruhestrom wie HT7333 oder MCP1700.
- Miss den Strom erneut. Liegt er nicht bei etwa 4–5 µA, ist meist ein angeschlossenes Modul schuld: LEDs und Regler auf Modulen ziehen genauso Strom.
Ein Sensor, der monatelang mit Batterien läuft: NTC und nRF24L01

Jetzt setzen wir alles zusammen: Ein 3,3-V-Pro-Mini wacht alle fünf Minuten auf, misst mit einem NTC-Thermistor die Temperatur sowie seine eigene Versorgungsspannung, schickt das Ergebnis per nRF24L01 an einen Empfänger und schläft wieder ein. Zwei Kniffe sind wichtig. Erstens hängt der NTC-Teiler nicht an 5V oder VCC, sondern an einem Digitalpin; so zieht er nur während der wenigen Millisekunden der Messung Strom. Ein dauerhaft eingeschalteter Teiler aus 10 kΩ + 10 kΩ würde bei 3 V 150 µA verbrauchen, das Dreißigfache des Schlafstroms. Zweitens braucht die Akkuspannung keine Zusatzteile: Der Code berechnet VCC in Millivolt, indem er die interne 1,1-V-Referenz des ATmega328P mit der Versorgung vergleicht. Da die NTC-Messung ratiometrisch ist, bleibt die Temperatur auch bei sinkender Versorgungsspannung korrekt.
| Bauteil | Pro Mini (3,3 V) | Hinweis |
|---|---|---|
| nRF24L01 VCC / GND | VCC / GND | Nur 3,3 V; 10–100 µF direkt an die Modulanschlüsse |
| nRF24L01 CE / CSN | D9 / D10 | Im Code RF24 radio(9, 10) |
| nRF24L01 SCK / MOSI / MISO | D13 / D11 / D12 | Hardware-SPI-Pins |
| Versorgung des NTC-Teilers | D4 → 10 kΩ → A0 | Nur während der Messung HIGH |
| NTC 10 kΩ (B = 3950) | A0 → NTC → GND | Lässt sich bis zur Messstelle verlängern |
| Batterie | VCC und GND (Regler entfernt) | 2 AA-Zellen oder 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}Bei jedem Aufwachen zieht der Knoten für etwa 20–40 ms einige Milliampere (rund 10 mA, während das nRF24 sendet). 40 ms alle fünf Minuten erhöhen den Durchschnitt nur um etwa 1 µA; der Rest sind der Schlafstrom von rund 4–5 µA und der Standby-Strom des nRF24 von 1 µA. Der Mittelwert bleibt also unter 10 µA, und rechnerisch reichen zwei AA-Zellen jahrzehntelang; in der Praxis setzt die Lagerfähigkeit der Batterien die Grenze. Mit dem Zähler im Paket erkennt der Empfänger verlorene Pakete, und vccMv zeigt dir, wann die Batterien gewechselt werden müssen. Als Empfänger eignet sich ein Uno oder Nano am USB; mit derselben RF24-Bibliothek rufst du openReadingPipe(1, ADDRESS) und startListening() auf und liest die Daten mit derselben Packet-Definition.
Arduino Pro Mini oder Nano?

| Merkmal | Arduino Pro Mini | Arduino Nano (V3) |
|---|---|---|
| Größe | 18 × 33 mm | 18 × 45 mm |
| USB | Keins, USB-TTL-Adapter nötig | Ja (Mini-USB, CH340 oder FT232) |
| Versionen | 3,3 V / 8 MHz und 5 V / 16 MHz | Nur 5 V / 16 MHz |
| Nutzbarer Programmspeicher | 30 KB | 30 KB (alter Bootloader) oder 31,5 KB (neuer Bootloader) |
| Analogeingänge | 8 (A0–A7) | 8 (A0–A7) |
| Schlafstrom | 1–3 mA, ohne LED und Regler wenige µA | Im mA-Bereich wegen USB-Chip, LED und Regler |
| Steckbrett | Passt nach dem Einlöten der Stiftleisten | Mit fertig bestückten Stiftleisten erhältlich |
| Fehlersuche mit dem seriellen Monitor | Solange der Adapter steckt | Jederzeit über das USB-Kabel |
| Ideal für | Kleine, batteriebetriebene, fest eingebaute Projekte | Lernen, Prototypen und Projekte am USB |
Kurz gesagt ist der Arduino Nano beim Lernen und für Prototypen bequemer: USB-Kabel rein, Code hochladen, im seriellen Monitor Fehler suchen. Steht das Projekt und soll es mit Batterien laufen, in ein kleines Gehäuse passen oder ohne Pegelwandler mit 3,3-V-Modulen sprechen, wechselst du zum Pro Mini. Da derselbe Code auf beiden Boards läuft, musst du dafür meist nur den Prozessor umstellen. Bei Projekten mit vielen Boards genügt ein einziger USB-TTL-Adapter für alle Pro Minis, und die Kosten pro Board sinken.
Projektideen mit dem Arduino Pro Mini
- Funk-Temperaturnetz: Stell in jeden Raum einen Pro-Mini-Knoten mit nRF24 und sammle die Daten an einem Empfänger.
- Batteriebetriebener Tür- und Fenstersensor: Mit einem Reedkontakt an D2 schläft das Board mit SLEEP_FOREVER und meldet sich nur, wenn die Tür aufgeht.
- Feuchtewächter für Topfpflanzen: Versorge den Bodenfeuchtesensor über einen Digitalpin und miss einmal pro Stunde; da der Sensor nicht dauernd unter Spannung steht, halten Batterie und Elektroden länger.
- Fernbedienung im Taschenformat: Bau mit einer IR-LED und ein paar Tastern eine Fernbedienung für Fernseher oder Klimaanlage; die Codes aus dem Artikel IR-Empfänger und Fernbedienung lassen sich auf die Senderseite übertragen.
- Leuchten zum Anziehen: Näh ein paar WS2812B-LEDs auf Jacke oder Tasche und erzeuge einen Lauflicht-Effekt.
- Datenlogger: Bau mit RTC und SD-Kartenmodul einen Logger, der wochenlang Temperatur oder Akkuspannung im Gehäuse aufzeichnet.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Fehler "stk500_getsync(): not in sync" | TX-RX gerade verbunden, DTR fehlt oder Reset-Zeitpunkt verpasst | TX an RXI und RX an TXO; DTR an GRN oder bei "Uploading..." Reset drücken |
| Upload klappt, aber das Timing ist doppelt so langsam oder schnell | Falsche Prozessor-Option (16 MHz statt 8 MHz oder umgekehrt) | Quarzaufdruck prüfen und mit der richtigen Option neu hochladen |
| Wirre Zeichen im seriellen Monitor | Prozessor falsch oder Baudrate passt nicht zum Code | Prozessor und Serial.begin-Geschwindigkeit prüfen |
| Im Schlaf immer noch über 1 mA | Power-LED, Regler oder LEDs auf Modulen | LED und Regler auslöten, Module über einen Digitalpin versorgen |
| Im Schlaf einige hundert µA zu viel | Offene (floatende) Eingänge | Ungenutzte Pins auf INPUT_PULLUP setzen |
| nRF24 funktioniert nicht oder verliert Pakete | Am VCC der 5-V-Version versorgt oder Spannung bricht beim Senden ein | Modul mit 3,3 V versorgen, 10–100 µF an die Anschlüsse |
| Board startet mit zwei AA-Zellen ständig neu | Spannung unter der BOD-Schwelle von 2,7 V | Batterien tauschen oder LiFePO4-Zelle verwenden |
| digitalRead(A6) liefert immer denselben Wert | A6 und A7 sind reine Analogeingänge | analogRead verwenden oder anderen Pin wählen |
Der Arduino Pro Mini ist der günstigste Weg, alles, was du mit dem Uno gelernt hast, auf ein fingerkuppengroßes Board zu bringen, ein Gerät, das von wenigen Mikroampere lebt. Teste deinen Code zuerst auf einem Uno oder Nano und übertrage die Schaltung dann auf den Pro Mini. Alle LED-, Taster-, LDR- und Sensorprojekte in der BlueGrays-App kannst du mit Schaltplan und fertigem Code Schritt für Schritt zuerst auf einem Uno aufbauen und danach mit denselben Pinnummern auf den Pro Mini übertragen.
Häufige Fragen
Wie programmiert man einen Arduino Pro Mini?
Da er keine USB-Buchse hat, nutzt man einen USB-TTL-Adapter mit CH340, CP2102 oder FT232. Verbunden werden GND, VCC, TX → RXI, RX → TXO und DTR → GRN; in der Arduino IDE wählst du das Board "Arduino Pro or Pro Mini" und den richtigen Prozessor. Ist DTR nicht angeschlossen, drückst du zu Beginn des Uploads von Hand den Reset-Taster.
Soll ich den Pro Mini mit 3,3 V oder 5 V kaufen?
Für ein Batterieprojekt mit 3,3-V-Modulen wie nRF24L01, BME280 oder SD-Karte nimmst du die 3,3-V-/8-MHz-Version. Brauchst du 5-V-Sensoren, Relaismodule oder mehr Rechengeschwindigkeit, passt die 5-V-/16-MHz-Version besser. Beide führen denselben Code aus, nur die Prozessor-Einstellung unterscheidet sich.
Wie viel Strom zieht ein Arduino Pro Mini?
Die 3,3-V-/8-MHz-Version zieht im Betrieb etwa 4–5 mA, die 5-V-/16-MHz-Version rund 15–20 mA. Mit LowPower schlafend braucht das unveränderte Board noch 1–3 mA, weil Power-LED und Regler weiterlaufen. Ohne diese beiden Bauteile sinkt der Schlafstrom mit aktivem Watchdog auf etwa 4–5 µA.
Kann man ein USB-Kabel an den Arduino Pro Mini anschließen?
Nein, der Pro Mini hat weder USB-Buchse noch USB-Chip. Für den Anschluss an den Computer brauchst du einen USB-TTL-Adapter; damit versorgst du das Board, lädst Code hoch und nutzt den seriellen Monitor. Willst du direkt über USB arbeiten, ist der Arduino Nano mit demselben Prozessor die praktischere Wahl.
Warum funktionieren A6 und A7 beim Pro Mini nicht als Digitalpins?
Beim ATmega328P hängen die Kanäle A6 und A7 nur am Analog-Multiplexer und haben keine digitale Ein-/Ausgabestufe. Deshalb funktionieren pinMode, digitalRead und digitalWrite dort nicht. Musst du einen digitalen Eingang wie einen Taster dort anschließen, nimm einen externen Pull-up-Widerstand und prüfe mit analogRead, ob der Wert über oder unter 512 liegt.
Wie lange hält ein Arduino Pro Mini mit Batterien?
Das hängt ganz vom Schlafstrom ab. Ein Board, das nie schläft, hält mit zwei AA-Zellen etwa drei Wochen, eines, das mit LowPower schläft, sonst aber unverändert ist, 1–3 Monate. Ohne Power-LED und Regler sinkt der Mittelwert unter 10 µA, und dieselben Zellen reichen jahrelang; dann setzt die Selbstentladung die Grenze.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED Blinken
Das allererste Hallo der Elektronik: eine einzelne LED an- und ausschalten. Der Arduino schaltet die LED in kurzen Abständen ein und aus, das Licht blinkt also schnell.

LED mit Taster schalten (Push)
Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

Lichtstärke messen mit LDR
Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

Einweg-Kommunikation zwischen 2 Arduinos
Du bringst zwei Arduinos über ein einziges Kabel zum Reden: Drückst du den Knopf am einen, geht die LED am anderen an, drückst du noch einmal, geht sie aus.

Bewegungsmelder mit Bewegungssensor
Ein einfacher Wächter, der Bescheid gibt, wenn jemand den Raum betritt. Der Bewegungsmelder spürt die Wärme, die der menschliche Körper abgibt; der Arduino lässt die LED leuchten, solange sich etwas…

Türsensor mit Reedschalter
Erkenne an einem Licht, ob deine Tür offen oder zu ist. An der Tür befestigst du einen kleinen Magneten, am Rahmen einen Schalter, der Magnete spürt; ist die Tür zu, liegen beide nebeneinander und…
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

