Futterautomat Katze Arduino: Selbstbau mit Zeitsteuerung
Futterautomat für Katze oder Hund mit Arduino bauen: Servo-Klappe, DS1307-Uhr, Portion per Taster, ESP32-Webseite und Telegram-Meldung bei jeder Fütterung.
Ein Futterautomat ist ein kleiner elektronischer Spender, der deiner Katze oder deinem Hund zu festen Zeiten eine bestimmte Menge Trockenfutter gibt. Für einen Futterautomaten mit Arduino brauchst du einen Futterbehälter, einen Servomotor, der die Öffnung auf- und zumacht, ein RTC-Modul (Echtzeituhr), das die Uhrzeit nie vergisst, und zwei Taster zum Einstellen der Portion. Die Kosten liegen weit unter denen fertiger Geräte, und du bestimmst selbst, wann und wie viel es gibt.
In dieser Anleitung bauen wir zuerst die Basisversion mit dem Arduino Uno: drei Mahlzeiten pro Tag mit einer DS1307-Uhr, Behälter mit SG90-Servoklappe, ein Taster für sofortiges Füttern, ein zweiter für die Portion (1–5) und eine Uhrzeitanzeige auf dem I2C-LCD. Danach siehst du in der ESP32-Version, wie du die Futterzeiten im Browser deines Handys änderst und bei jeder Mahlzeit eine Telegram-Nachricht bekommst, und zum Schluss dieselbe Logik mit Raspberry Pi Pico und MicroPython. Am Ende findest du Tipps zum Gehäusebau, damit das Futter nicht klemmt, das Tier den Automaten nicht umwirft und alles stabil bleibt.

Was ist ein Futterautomat und wie funktioniert er?
Das Prinzip ist simpel: Das Futter wartet oben im Behälter und rutscht per Schwerkraft zur engen Auslauföffnung. Eine Klappe am Servomotor verschließt diese Öffnung. Der Arduino liest in jedem Durchlauf die Uhrzeit vom RTC-Modul; stimmt sie mit einer Futterzeit in der Liste überein, öffnet der Servo die Klappe kurz, das Futter fällt in den Napf und die Klappe schließt wieder. Wie oft die Klappe öffnet, bestimmt die Portion. Dank der Knopfzelle auf dem RTC-Modul geht die Uhrzeit auch bei Stromausfall nicht verloren; sobald wieder Strom anliegt, füttert der Automat zur richtigen Zeit weiter. Die Taster dienen zum manuellen Füttern und zum Einstellen der Portion, und der Buzzer gibt vor jeder Mahlzeit ein kurzes Signal.
| Bauteil | Aufgabe | Hinweis |
|---|---|---|
| Arduino Uno (oder Nano) | Steuerplatine | Mit dem Nano wird das Gehäuse kleiner |
| SG90 Servomotor | Öffnet und schließt die Klappe | Für schwere Klappen MG90S oder MG996R |
| DS1307 RTC-Modul | Hält Uhrzeit und Datum | CR2032 erhält die Zeit bei Stromausfall; braucht 5 V |
| 2 Drucktaster | Manuelles Füttern und Portionswahl | Interner Pull-up, kein Widerstand nötig |
| Aktiver Buzzer | Signal vor der Mahlzeit | Das Tier gewöhnt sich mit der Zeit an den Ton |
| I2C-LCD 16x2 | Zeigt Uhrzeit und Portion | Adresse meist 0x27 oder 0x3F |
| 5-V-2-A-Netzteil | Versorgung für Servo und Platine | Den Servo nicht über USB versorgen |
| Behälter, Trichter, Gehäuse | Nimmt das Futter auf und leitet es | PET-Flasche, Vorratsdose, Forex oder 3D-Druck |
Mechanik wählen: Klappe, Förderschnecke oder Drehtrommel
Das Herzstück des Futterautomaten ist die Mechanik, die das Futter freigibt; sie beeinflusst sowohl Code als auch Gehäuse. Für Einsteiger ist der Behälter mit Servoklappe am einfachsten: Eine Klappe am Servoarm verschließt die Öffnung, und beim Öffnen fließt das Futter. Für genauere Portionen kannst du eine Förderschnecke oder eine Drehtrommel mit Kammern nehmen; sie fördern das Futter nach Volumen, sodass bei jeder Drehung fast dieselbe Menge fällt, verlangen aber 3D-Druck oder sorgfältigere mechanische Arbeit.
| Mechanik | Motor | Portionsgenauigkeit | Schwierigkeit |
|---|---|---|---|
| Behälter mit Servoklappe | SG90 / MG90S | Mittel, hängt von der Futtergröße ab | Einfach |
| Förderschnecke | FS90R (kontinuierlicher Servo) oder 28BYJ-48 | Hoch | Mittel, 3D-Druck nötig |
| Drehtrommel (Kammerrad) | 28BYJ-48 Schrittmotor | Hoch, entspricht dem Kammervolumen | Mittel |
| Schieber | MG996R Servo | Mittel | Einfach bis mittel |

Schaltplan: Pins für Arduino Uno, ESP32 und Pico
| Bauteil / Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Servo-Signal (orange) | D9 | GPIO 18 | GP15 |
| Servo VCC (rot) | Externe 5 V | Externe 5 V | Externe 5 V |
| Servo GND (braun) | GND (gemeinsam) | GND (gemeinsam) | GND (gemeinsam) |
| Futter-Taster | D2 – GND | GPIO 25 – GND | GP14 – GND |
| Portions-Taster | D3 – GND | GPIO 26 – GND | GP13 – GND |
| Aktiver Buzzer (+) | D8 | GPIO 27 | GP16 |
| RTC / LCD SDA | A4 | Nicht nötig (NTP) | GP4 (DS3231) |
| RTC / LCD SCL | A5 | Nicht nötig (NTP) | GP5 (DS3231) |
| RTC VCC | 5V (DS1307) | — | 3V3 (DS3231) |
Aufbau Schritt für Schritt
- Installiere in der Arduino IDE über den Bibliotheksverwalter RTClib (Adafruit) und LiquidCrystal I2C (Frank de Brabander); die Servo-Bibliothek ist in der IDE schon enthalten.
- Schließe RTC-Modul und LCD an denselben I2C-Bus an (A4 = SDA, A5 = SCL); sie kommen sich nicht in die Quere, da sie unterschiedliche Adressen haben (0x68 und 0x27).
- Verbinde das Servo-Signalkabel mit D9, das rote und das braune Kabel mit dem externen 5-V-Netzteil und verbinde das Netzteil-GND mit dem Arduino-GND.
- Schließe jeweils ein Beinchen der Taster an D2 und D3 an, das andere an GND. Im Code wird INPUT_PULLUP verwendet, ein externer Widerstand ist nicht nötig.
- Setze die CR2032 in die RTC ein und lade den Code hoch. Wurde die RTC noch nie gestellt, übernimmt sie die Computerzeit vom Zeitpunkt des Kompilierens.
- Warte, bis der Code den Servo auf 0° gefahren hat, bevor du den Arm montierst, und schraube ihn bei geschlossener Klappe fest. So passen die Winkel ACIK und KAPALI genau zu deiner Mechanik.
- Stelle einen Napf unter den Behälter, drücke ein paar Mal den Futter-Taster und kalibriere die Portion, indem du das gefallene Futter wiegst.
1#include <Wire.h>
2#include <RTClib.h>
3#include <Servo.h>
4#include <LiquidCrystal_I2C.h>
5
6RTC_DS1307 rtc;
7Servo kapak;
8LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
9
10const int SERVO_PIN = 9;
11const int FEED_BTN = 2; // elle besleme / manual feed
12const int PORTION_BTN = 3; // porsiyon seçimi / portion select
13const int BUZZER_PIN = 8; // aktif buzzer / active buzzer
14const int KAPALI = 0; // kapak kapalı açısı / lid closed angle
15const int ACIK = 80; // kapak açık açısı / lid open angle
16
17const byte ogunler[][2] = { {8, 0}, {13, 0}, {19, 30} }; // öğün saatleri / feeding times
18const byte OGUN_SAYISI = sizeof(ogunler) / sizeof(ogunler[0]);
19
20byte porsiyon = 2; // 1-5 arası / between 1 and 5
21long sonBesleme = -1; // son öğün anahtarı / last feeding key
22bool oncekiBesle = HIGH, oncekiPors = HIGH;
23unsigned long sonEkran = 0;
24
25void bip(int ms) {
26 digitalWrite(BUZZER_PIN, HIGH);
27 delay(ms);
28 digitalWrite(BUZZER_PIN, LOW);
29}
30
31void mamaVer(byte adet) {
32 bip(300); // öğün sinyali / meal signal
33 for (byte i = 0; i < adet; i++) {
34 kapak.write(ACIK); // kapağı aç / open the lid
35 delay(400);
36 kapak.write(KAPALI); // kapağı kapat / close the lid
37 delay(500);
38 }
39}
40
41void ekranYaz(const DateTime &t) {
42 char satir[17];
43 snprintf(satir, sizeof(satir), "Saat %02d:%02d:%02d", t.hour(), t.minute(), t.second());
44 lcd.setCursor(0, 0);
45 lcd.print(satir);
46 snprintf(satir, sizeof(satir), "Porsiyon: %d ", porsiyon);
47 lcd.setCursor(0, 1);
48 lcd.print(satir);
49}
50
51void setup() {
52 pinMode(FEED_BTN, INPUT_PULLUP);
53 pinMode(PORTION_BTN, INPUT_PULLUP);
54 pinMode(BUZZER_PIN, OUTPUT);
55 kapak.attach(SERVO_PIN);
56 kapak.write(KAPALI);
57 lcd.init();
58 lcd.backlight();
59 if (!rtc.begin()) { // RTC bulunamadı / RTC not found
60 lcd.print("RTC yok!");
61 while (true);
62 }
63 if (!rtc.isrunning()) { // saat ayarlı değil / clock not set
64 rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
65 }
66}
67
68void loop() {
69 DateTime now = rtc.now();
70
71 for (byte i = 0; i < OGUN_SAYISI; i++) {
72 if (now.hour() == ogunler[i][0] && now.minute() == ogunler[i][1]) {
73 long anahtar = (long)now.day() * 1440L + now.hour() * 60 + now.minute();
74 if (anahtar != sonBesleme) { // bu dakikada verilmediyse / not yet served this minute
75 sonBesleme = anahtar;
76 mamaVer(porsiyon);
77 }
78 }
79 }
80
81 bool b1 = digitalRead(FEED_BTN);
82 if (b1 == LOW && oncekiBesle == HIGH) { // basıldığı an / moment of press
83 mamaVer(porsiyon);
84 }
85 oncekiBesle = b1;
86
87 bool b2 = digitalRead(PORTION_BTN);
88 if (b2 == LOW && oncekiPors == HIGH) {
89 porsiyon = porsiyon % 5 + 1; // 1,2,3,4,5,1... / cycles 1 to 5
90 bip(80);
91 }
92 oncekiPors = b2;
93
94 if (millis() - sonEkran >= 1000) { // ekranı saniyede bir yenile / refresh once per second
95 sonEkran = millis();
96 ekranYaz(now);
97 }
98 delay(20); // basit debounce / simple debounce
99}Wie funktioniert der Code?
| Abschnitt | Was passiert? |
|---|---|
| ogunler[][2] | Speichert die Futterzeiten als Stunde-Minute-Paare; für mehr Mahlzeiten fügst du einfach Zeilen hinzu. |
| mamaVer(adet) | Lässt den Buzzer ertönen und öffnet die Klappe so oft für je 400 ms, wie die Portion vorgibt. |
| anahtar / sonBesleme | Stellt sicher, dass die Mahlzeit nur einmal ausgegeben wird, auch wenn die Schleife in derselben Minute hunderte Male läuft. |
| rtc.isrunning() | Setzt die Uhr auf die Kompilierzeit, wenn die RTC nie gestellt wurde oder die Batterie leer ist. |
| oncekiBesle / oncekiPors | Erkennt den Moment des Drückens (fallende Flanke), nicht das Gedrückthalten. |
| ekranYaz() | Aktualisiert das LCD einmal pro Sekunde; bei jedem Durchlauf zu schreiben würde flackern und bremsen. |
Die wichtigste Zeile im Code ist der Fütterungsschlüssel. Die loop-Funktion des Arduino läuft dutzende Male pro Sekunde; um 08:00 Uhr ist die Bedingung die ganze Minute lang immer wieder wahr. Bei einem einfachen Vergleich würde der Automat in dieser einen Minute den ganzen Behälter leeren. Deshalb wandeln wir Tag, Stunde und Minute in eine einzige Zahl um: Tag × 1440 + Stunde × 60 + Minute. Ist diese Zahl gleich der der letzten Fütterung, wurde die Mahlzeit schon ausgegeben. Dass auch der Tag einfließt, sorgt dafür, dass am nächsten Tag zur selben Uhrzeit wieder gefüttert wird, selbst wenn nur eine Mahlzeit in der Liste steht.
Portion kalibrieren: Wie viel Gramm Futter fällt?
Bei einem Behälter mit Servoklappe hängt die Menge davon ab, wie lange die Klappe offen bleibt, wie groß die Öffnung ist und wie groß die Futterstücke sind. Deshalb solltest du die Portion messen statt berechnen. Stelle einen leeren Napf auf die Küchenwaage, drücke bei Portion 1 zehnmal den Futter-Taster und teile das Gesamtgewicht durch 10; das ist das Durchschnittsgewicht einer Klappenöffnung. Fallen bei 10 Öffnungen zum Beispiel 120 g, sind das etwa 12 g pro Öffnung. Braucht deine Katze 60 g pro Tag und bekommt drei Mahlzeiten, sind das 20 g pro Mahlzeit; du stellst also Portion 2 ein (etwa 24 g) oder verkürzt die Öffnungszeit etwas unter 400 ms. Die Tagesmenge richtest du nach der Tabelle auf der Futterpackung und der Empfehlung deines Tierarztes.
ESP32-Version: Futterzeiten per Web und Telegram-Meldung
Der ESP32 bringt dem Futterautomaten zwei große Vorteile. Erstens holt er die Uhrzeit per NTP aus dem Internet, sodass du kein RTC-Modul brauchst und die Zeit nicht abdriftet. Zweitens kann er einen eigenen Webserver betreiben, sodass du Futterzeiten und Portion im Browser deines Handys im selben WLAN ändern kannst. Nach jeder Fütterung kommt eine Telegram-Nachricht "Mama verildi", sodass du auch unterwegs weißt, dass dein Tier satt geworden ist. Zum Kompilieren installierst du im Bibliotheksverwalter UniversalTelegramBot und die dazugehörige ArduinoJson. Den Bot-Token bekommst du in Telegram bei BotFather, die Chat-ID, nachdem du deinem Bot eine Nachricht geschickt hast; Details im Beitrag ESP32 Telegram Bot.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4#include <WiFiClientSecure.h>
5#include <UniversalTelegramBot.h>
6#include <time.h>
7
8const char* WIFI_SSID = "WIFI_ADI"; // Wi-Fi adın / your Wi-Fi name
9const char* WIFI_PASS = "WIFI_SIFRESI"; // Wi-Fi şifren / your Wi-Fi password
10#define BOT_TOKEN "123456789:ABCdefGhIJKlmnoPQRstuVWxyz" // BotFather token'ı / BotFather token
11#define CHAT_ID "123456789" // senin chat ID'n / your chat ID
12
13const int SERVO_PIN = 18;
14const int SERVO_CH = 0; // yalnız core 2.x için / core 2.x only
15const int FEED_BTN = 25;
16const int PORTION_BTN = 26;
17const int BUZZER_PIN = 27;
18const int KAPALI = 0;
19const int ACIK = 80;
20
21WebServer server(80);
22Preferences prefs;
23WiFiClientSecure secured;
24UniversalTelegramBot bot(BOT_TOKEN, secured);
25
26uint8_t saatH[3] = {8, 13, 19}; // öğün saatleri / feeding hours
27uint8_t saatM[3] = {0, 0, 30}; // öğün dakikaları / feeding minutes
28uint8_t porsiyon = 2;
29long sonBesleme = -1;
30
31void servoYaz(int aci) {
32 uint32_t us = 500 + (uint32_t)aci * 1900 / 180; // 500-2400 us darbe / pulse
33 uint32_t duty = us * 16383UL / 20000UL; // 14 bit, 20 ms periyot / period
34#if ESP_ARDUINO_VERSION_MAJOR >= 3
35 ledcWrite(SERVO_PIN, duty);
36#else
37 ledcWrite(SERVO_CH, duty);
38#endif
39}
40
41void bip(int ms) {
42 digitalWrite(BUZZER_PIN, HIGH);
43 delay(ms);
44 digitalWrite(BUZZER_PIN, LOW);
45}
46
47void ayarlariOku() {
48 prefs.begin("mama", false);
49 char k[4];
50 for (int i = 0; i < 3; i++) {
51 snprintf(k, sizeof(k), "h%d", i);
52 saatH[i] = prefs.getUChar(k, saatH[i]);
53 snprintf(k, sizeof(k), "m%d", i);
54 saatM[i] = prefs.getUChar(k, saatM[i]);
55 }
56 porsiyon = prefs.getUChar("p", porsiyon);
57 prefs.end();
58}
59
60void ayarlariYaz() { // flash'a kaydet / save to flash
61 prefs.begin("mama", false);
62 char k[4];
63 for (int i = 0; i < 3; i++) {
64 snprintf(k, sizeof(k), "h%d", i);
65 prefs.putUChar(k, saatH[i]);
66 snprintf(k, sizeof(k), "m%d", i);
67 prefs.putUChar(k, saatM[i]);
68 }
69 prefs.putUChar("p", porsiyon);
70 prefs.end();
71}
72
73void mamaVer(uint8_t adet, const char* neden) {
74 bip(300);
75 for (uint8_t i = 0; i < adet; i++) {
76 servoYaz(ACIK);
77 delay(400);
78 servoYaz(KAPALI);
79 delay(500);
80 }
81 if (WiFi.status() == WL_CONNECTED) { // Telegram bildirimi / Telegram notification
82 String msg = "Mama verildi / Food served: ";
83 msg += adet;
84 msg += " porsiyon (";
85 msg += neden;
86 msg += ")";
87 bot.sendMessage(CHAT_ID, msg, "");
88 }
89}
90
91void sayfaGonder() { // ayar sayfası / settings page
92 String h = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
93 h += "<meta name='viewport' content='width=device-width'><title>Mama</title></head><body>";
94 h += "<h2>Mama Makinesi</h2><form action='/kaydet'>";
95 for (int i = 0; i < 3; i++) {
96 char satir[100];
97 snprintf(satir, sizeof(satir), "Öğün %d: <input name='t%d' type='time' value='%02d:%02d'><br>",
98 i + 1, i, saatH[i], saatM[i]);
99 h += satir;
100 }
101 h += "Porsiyon (1-5): <input name='p' type='number' min='1' max='5' value='";
102 h += porsiyon;
103 h += "'><br><button>Kaydet</button></form>";
104 h += "<form action='/besle'><button>Şimdi besle</button></form></body></html>";
105 server.send(200, "text/html", h);
106}
107
108void kaydet() {
109 for (int i = 0; i < 3; i++) {
110 String ad = String("t") + i;
111 if (server.hasArg(ad)) {
112 String v = server.arg(ad); // "HH:MM" biçimi / format
113 if (v.length() >= 5) {
114 long hh = v.substring(0, 2).toInt();
115 long mm = v.substring(3, 5).toInt();
116 if (hh >= 0 && hh < 24 && mm >= 0 && mm < 60) {
117 saatH[i] = hh;
118 saatM[i] = mm;
119 }
120 }
121 }
122 }
123 if (server.hasArg("p")) {
124 long p = server.arg("p").toInt();
125 if (p < 1) p = 1;
126 if (p > 5) p = 5;
127 porsiyon = p;
128 }
129 ayarlariYaz();
130 server.sendHeader("Location", "/");
131 server.send(303);
132}
133
134void setup() {
135 Serial.begin(115200);
136 pinMode(FEED_BTN, INPUT_PULLUP);
137 pinMode(PORTION_BTN, INPUT_PULLUP);
138 pinMode(BUZZER_PIN, OUTPUT);
139#if ESP_ARDUINO_VERSION_MAJOR >= 3
140 ledcAttach(SERVO_PIN, 50, 14); // 50 Hz, 14 bit (core 3.x)
141#else
142 ledcSetup(SERVO_CH, 50, 14); // 50 Hz, 14 bit (core 2.x)
143 ledcAttachPin(SERVO_PIN, SERVO_CH);
144#endif
145 servoYaz(KAPALI);
146 ayarlariOku();
147
148 WiFi.mode(WIFI_STA);
149 WiFi.begin(WIFI_SSID, WIFI_PASS);
150 while (WiFi.status() != WL_CONNECTED) {
151 delay(500);
152 Serial.print(".");
153 }
154 Serial.println();
155 Serial.println(WiFi.localIP()); // tarayıcıda bu adresi aç / open this address in the browser
156
157 configTzTime("<+03>-3", "pool.ntp.org"); // Türkiye UTC+3 / Turkey UTC+3
158 secured.setCACert(TELEGRAM_CERTIFICATE_ROOT);
159
160 server.on("/", sayfaGonder);
161 server.on("/kaydet", kaydet);
162 server.on("/besle", []() {
163 mamaVer(porsiyon, "web");
164 server.sendHeader("Location", "/");
165 server.send(303);
166 });
167 server.begin();
168 bot.sendMessage(CHAT_ID, "Mama makinesi acildi / Feeder online", "");
169}
170
171void loop() {
172 server.handleClient();
173
174 struct tm t;
175 if (getLocalTime(&t, 10)) { // saat senkronize ise / if time is synced
176 for (int i = 0; i < 3; i++) {
177 if (t.tm_hour == saatH[i] && t.tm_min == saatM[i]) {
178 long anahtar = (long)t.tm_yday * 1440L + t.tm_hour * 60 + t.tm_min;
179 if (anahtar != sonBesleme) {
180 sonBesleme = anahtar;
181 mamaVer(porsiyon, "zamanli / scheduled");
182 }
183 }
184 }
185 }
186
187 static bool oncekiBesle = HIGH, oncekiPors = HIGH;
188 bool b1 = digitalRead(FEED_BTN);
189 if (b1 == LOW && oncekiBesle == HIGH) mamaVer(porsiyon, "buton / button");
190 oncekiBesle = b1;
191
192 bool b2 = digitalRead(PORTION_BTN);
193 if (b2 == LOW && oncekiPors == HIGH) {
194 porsiyon = porsiyon % 5 + 1;
195 ayarlariYaz();
196 bip(80);
197 }
198 oncekiPors = b2;
199 delay(20);
200}In diesem Code verwenden wir keine Servo-Bibliothek, sondern erzeugen mit der LEDC-Hardware-PWM des ESP32 ein Signal mit 50 Hz und 14 Bit Auflösung. Eine Pulsbreite von 500–2400 Mikrosekunden entspricht 0–180 Grad. Da sich die LEDC-Funktionen im ESP32-Arduino-Core 3.x geändert haben, werden beide Versionen über ESP_ARDUINO_VERSION_MAJOR getrennt; der Code lässt sich also mit 2.x und 3.x kompilieren. Futterzeiten und Portion werden mit Preferences in den Flash geschrieben und gehen bei Stromausfall nicht verloren. Öffne im Browser die IP-Adresse des ESP32 (steht im Seriellen Monitor), wähle die Zeiten und drücke auf Kaydet. Die Zeitzone ist auf die Türkei (UTC+3) eingestellt; in einem anderen Land änderst du den String in der Zeile configTzTime. Details zu NTP findest du im Beitrag ESP32 NTP-Uhr.
Futterautomat mit Raspberry Pi Pico und MicroPython
Auch im Pico steckt eine Uhr, sie wird bei Stromausfall aber zurückgesetzt; deshalb ist eine batteriegepufferte RTC Pflicht. Da der Pico mit 3,3 V läuft, nimmst du statt des DS1307 einen DS3231: Er nutzt dieselbe Adresse 0x68 und dieselben Zeitregister und driftet dank temperaturkompensiertem Quarz nur etwa eine Minute pro Jahr. Der folgende Code braucht keine zusätzliche Bibliothek; er liest die RTC direkt per I2C und steuert den Servo mit 50 Hz PWM. Um die Uhr zum ersten Mal zu stellen, entfernst du das Kommentarzeichen vor der Zeile set_time, führst den Code einmal aus und kommentierst die Zeile danach wieder aus.
1from machine import Pin, PWM, I2C
2import time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
5RTC_ADDR = 0x68 # DS3231 adresi / DS3231 address
6
7servo = PWM(Pin(15))
8servo.freq(50) # servo için 50 Hz / 50 Hz for servo
9buzzer = Pin(16, Pin.OUT) # aktif buzzer / active buzzer
10btn_feed = Pin(14, Pin.IN, Pin.PULL_UP)
11btn_portion = Pin(13, Pin.IN, Pin.PULL_UP)
12
13SCHEDULE = [(8, 0), (13, 0), (19, 30)] # öğün saatleri / feeding times
14CLOSED = 0
15OPEN = 80
16portion = 2
17last_key = -1
18
19def bcd2dec(b):
20 return (b >> 4) * 10 + (b & 0x0F)
21
22def dec2bcd(v):
23 return ((v // 10) << 4) | (v % 10)
24
25def set_time(year, month, day, hour, minute, second):
26 # saati bir kez kur / set the clock once
27 data = bytes([dec2bcd(second), dec2bcd(minute), dec2bcd(hour), 1,
28 dec2bcd(day), dec2bcd(month), dec2bcd(year % 100)])
29 i2c.writeto_mem(RTC_ADDR, 0x00, data)
30
31def read_time():
32 d = i2c.readfrom_mem(RTC_ADDR, 0x00, 7)
33 minute = bcd2dec(d[1] & 0x7F)
34 hour = bcd2dec(d[2] & 0x3F) # 24 saat modu / 24-hour mode
35 day = bcd2dec(d[4] & 0x3F)
36 return hour, minute, day
37
38def set_angle(angle):
39 us = 500 + angle * 1900 // 180 # 500-2400 us darbe / pulse
40 servo.duty_u16(us * 65535 // 20000)
41
42def beep(ms):
43 buzzer.value(1)
44 time.sleep_ms(ms)
45 buzzer.value(0)
46
47def feed(count):
48 beep(300) # öğün sinyali / meal signal
49 for _ in range(count):
50 set_angle(OPEN)
51 time.sleep_ms(400)
52 set_angle(CLOSED)
53 time.sleep_ms(500)
54
55# set_time(2027, 1, 25, 8, 0, 0) # ilk kurulumda bir kez / once at first setup
56
57set_angle(CLOSED)
58prev_feed = 1
59prev_portion = 1
60
61while True:
62 h, m, day = read_time()
63 for sh, sm in SCHEDULE:
64 if h == sh and m == sm:
65 key = day * 1440 + h * 60 + m
66 if key != last_key: # bu dakikada verilmediyse / not yet served
67 last_key = key
68 feed(portion)
69
70 f = btn_feed.value()
71 if f == 0 and prev_feed == 1: # basıldığı an / moment of press
72 feed(portion)
73 prev_feed = f
74
75 p = btn_portion.value()
76 if p == 0 and prev_portion == 1:
77 portion = portion % 5 + 1
78 beep(80)
79 print("Porsiyon / Portion:", portion)
80 prev_portion = p
81
82 time.sleep_ms(50) # basit debounce / simple debounceTipps für Gehäuse und Modellbau
- Behälter: Eine 1,5-Liter-PET-Flasche oder eine Vorratsdose mit Deckel reicht. Ein Deckel schützt das Futter vor Feuchtigkeit und neugierigen Pfoten; für Teile mit Futterkontakt nimmst du lebensmittelechten Kunststoff.
- Bodenneigung: Der Boden des Behälters sollte mindestens 45 Grad geneigt sein. Bei flacheren Böden bleibt Futter in den Ecken liegen und die letzten Mahlzeiten fallen zu klein aus.
- Auslauf: Trockenfutterstücke sind meist 8–15 mm groß; mache die Öffnung 25–35 mm breit. Eine zu enge Öffnung klemmt, eine zu weite zerdrückt die Stücke beim Schließen der Klappe.
- Klappe: Nimm eine Platte aus Forex, Schaumkarton oder 3D-Druck und befestige sie mit einer M2-Schraube am Servoarm. Kleber allein löst sich mit der Zeit.
- Stabiler Boden: Katzen und Hunde schieben den Automaten und versuchen, ihn umzuwerfen. Mach den Boden breit, beschwere ihn oder befestige das Gehäuse an der Wand.
- Kabelschutz: Ummantele das Netzteilkabel mit einem Spiralschlauch und setze die Elektronik in ein geschlossenes Gehäuse; angeknabberte Kabel sind für Tier und Gerät gefährlich.
- Dauerhafte Schaltung: Ein Breadboard kann sich durch Vibration lockern. Löte die funktionierende Schaltung auf eine Lochrasterplatine.
Ideen zum Weiterentwickeln des Futterautomaten
- Wiegender Napf: Miss mit HX711 und Wägezelle das Gewicht des Napfs; ist er noch voll, gibt es keine neue Portion, und du fütterst grammgenau.
- Warnung bei leerem Behälter: Der berührungslose Füllstandssensor XKC-Y25 wird außen am Behälter angebracht und meldet per Telegram, wenn das Futter knapp wird.
- Benachrichtigung mit Foto: Schicke mit der ESP32-CAM bei jeder Mahlzeit ein Foto deines fressenden Tieres aufs Handy.
- Automatischer Wassernapf: Fülle mit einer Mini-Wasserpumpe und einem Füllstandssensor auch den Wassernapf automatisch nach.
- Lockruf: Spiele mit dem DFPlayer Mini zur Futterzeit einen mit deiner eigenen Stimme aufgenommenen Ruf ab.
- Einstellungen speichern: Schreibe in der Arduino-Version die Portion ins EEPROM, damit sie nach einem Stromausfall nicht auf den Standardwert zurückfällt.
Häufige Fehler und Lösungen
| Problem | Mögliche Ursache | Lösung |
|---|---|---|
| Arduino startet neu, wenn sich der Servo bewegt | Servo hängt am 5V-Pin der Platine | Externes 5-V-2-A-Netzteil nutzen, GNDs verbinden |
| Zur Futterzeit leert sich der ganze Behälter | In derselben Minute wird wiederholt gefüttert | Die Prüfung anahtar / sonBesleme im Code beibehalten |
| Uhr springt bei jedem Start auf die Kompilierzeit | RTC-Batterie fehlt oder ist leer | CR2032 tauschen, Kontakte des Batteriehalters prüfen |
| LCD zeigt keinen Text, nur Kästchen | Kontrast falsch oder falsche I2C-Adresse | Das Potentiometer hinten drehen, Adresse 0x3F probieren |
| Futter klemmt an der Öffnung | Öffnung zu eng oder Boden zu flach | Öffnung vergrößern, Neigung erhöhen, Rüttelbewegung der Klappe hinzufügen |
| Servo brummt und zittert im geschlossenen Zustand | Klappe sitzt nicht richtig, Servo korrigiert ständig | KAPALI-Winkel um ein paar Grad ändern oder nach der Bewegung kapak.detach() nutzen |
| ESP32 füttert gar nicht | NTP noch nicht synchronisiert oder kein WLAN | Verbindung im Seriellen Monitor prüfen; der Code wartet, bis die Zeit da ist |
Ein Futterautomat verbindet Servo, RTC, Taster und WLAN in einem einzigen Alltagsprojekt und eignet sich deshalb sowohl als Schulprojekt als auch als Gerät, das du zu Hause wirklich nutzt. Details zu Servo und RTC findest du in den Beiträgen Servomotor und RTC-Uhrmodul. In der BlueGrays-App findest du Projekte zu Servo, Uhr mit RTC, ESP32 NTP und Alarm mit Telegram-Meldung mit Schaltplan und Code, mit denen du jeden Teil dieses Futterautomaten einzeln ausprobieren kannst.
Häufige Fragen
Welchen Servo brauche ich für einen Futterautomaten?
Für eine leichte Klappe reicht der SG90, er ist die günstigste Wahl. Ist die Klappe schwer, der Behälter groß oder drückt das Futter auf die Klappe, nimm einen Servo mit Metallgetriebe wie MG90S oder MG996R. Für Förderschnecken oder Drehtrommeln passen ein kontinuierlicher FS90R oder ein 28BYJ-48 Schrittmotor besser.
Vergisst der Futterautomat bei Stromausfall die Uhrzeit?
Dank der CR2032 im RTC-Modul bleibt die Zeit erhalten, und der Automat füttert nach dem Stromausfall zur richtigen Zeit weiter. Eine Mahlzeit, die in den Ausfall fällt, wird aber übersprungen. Die ESP32-Version holt sich die Zeit nach der Wiederverbindung mit dem WLAN per NTP aus dem Internet.
Wie viele Mahlzeiten pro Tag kann ein Arduino-Futterautomat ausgeben?
Du kannst im Array ogunler beliebig viele Zeilen ergänzen und so so viele Mahlzeiten festlegen, wie du willst. Der Speicher des Arduino Uno reicht für dutzende Mahlzeiten locker aus. Praktisch begrenzt wird es durch den Tagesbedarf deines Tieres und den Fütterungsplan, den dein Tierarzt empfiehlt.
Läuft der Futterautomat mit Powerbank oder Batterien?
Kurzzeitig ja; eine Powerbank mit 5-V-Ausgang ist die praktischste Lösung. Arduino Uno und LCD ziehen zusammen etwa 60–70 mA, daher hält eine 10000-mAh-Powerbank grob 3–4 Tage. Manche Powerbanks schalten sich bei geringem Strom ab, deshalb ist für den Dauerbetrieb ein 5-V-Netzteil zuverlässiger.
Kann ich den ESP32-Futterautomaten von außerhalb des Hauses steuern?
Die Webseite im Beispiel funktioniert nur im selben WLAN. Für den Zugriff von außen kannst du den Telegram-Bot um Befehle wie /besle erweitern oder einen Cloud-Dienst wie MQTT oder Blynk nutzen. Eine Portweiterleitung im Router ist aus Sicherheitsgründen nicht empfehlenswert.
Kann ich den Futterautomaten für Nassfutter verwenden?
Der Behälter mit Servoklappe ist nur für Trockenfutter gedacht; Nassfutter fließt nicht, sammelt sich an der Klappe und verdirbt schnell. Für Nassfutter brauchst du Konstruktionen, bei denen jede Mahlzeit in einem eigenen Fach wartet, dessen Deckel der Servo zur Futterzeit öffnet, am besten mit einem Kühlakku gekühlt.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED mit Taster ein- und ausschalten
Einmal drücken und das Licht geht an, noch einmal drücken und es geht aus, genau wie der Lichtschalter in deinem Zimmer.

Verwendung von Servomotoren
Der Arm eines kleinen Servomotors dreht sich nacheinander in drei Stellungen: ganz an den Anfang, genau in die Mitte und ganz ans Ende, mit jeweils zwei Sekunden Pause.

DS1302-RTC-Uhrenmodul einrichten
Du bringst ein kleines Uhrmodul zum Laufen, das die Zeit nicht vergisst, selbst wenn der Arduino ausgeschaltet ist.

DS1302 RTC-Uhr mit LCD-Anzeige
Eine kleine Tischuhr, die die Zeit auch bei Stromausfall nicht vergisst. Das Uhrmodul DS1302 hält die Zeit mit seiner eigenen kleinen Batterie; jede Sekunde liest der Arduino sie aus und schreibt…

Digitale Uhr mit ESP32 und RTC DS1307 (I2C + LCD)
In diesem Projekt zeigen wir Uhrzeit und Datum auf einem 16x2-I2C-LCD-Display mithilfe des DS1307-Echtzeituhrmoduls (RTC) an. Das DS1307 ist ein batteriegestütztes RTC, das die Uhrzeit auch dann beibehält, wenn das ESP32 ausgeschaltet ist. Beide Module teilen sich denselben I2C-Bus (SDA/SCL), sodass wir mit nur zwei Signalkabeln die Steuerung mehrerer Geräte erlernen. So lernen Sie das I2C-Protokoll und die Funktionsweise von RTC-Modulen in der Praxis kennen.

ESP32: Echtzeit aus dem Internet per NTP
Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.
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

