Ratgeber · 8 Min. Lesezeit

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.

SG90 Servomotor für die Klappe des Futterautomaten
SG90 Mikroservo: Er öffnet und schließt die Klappe des Futterbehälters zwischen 0° und 80° und gibt so die Portion frei.

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.

BauteilAufgabeHinweis
Arduino Uno (oder Nano)SteuerplatineMit dem Nano wird das Gehäuse kleiner
SG90 ServomotorÖffnet und schließt die KlappeFür schwere Klappen MG90S oder MG996R
DS1307 RTC-ModulHält Uhrzeit und DatumCR2032 erhält die Zeit bei Stromausfall; braucht 5 V
2 DrucktasterManuelles Füttern und PortionswahlInterner Pull-up, kein Widerstand nötig
Aktiver BuzzerSignal vor der MahlzeitDas Tier gewöhnt sich mit der Zeit an den Ton
I2C-LCD 16x2Zeigt Uhrzeit und PortionAdresse meist 0x27 oder 0x3F
5-V-2-A-NetzteilVersorgung für Servo und PlatineDen Servo nicht über USB versorgen
Behälter, Trichter, GehäuseNimmt das Futter auf und leitet esPET-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.

MechanikMotorPortionsgenauigkeitSchwierigkeit
Behälter mit ServoklappeSG90 / MG90SMittel, hängt von der Futtergröße abEinfach
FörderschneckeFS90R (kontinuierlicher Servo) oder 28BYJ-48HochMittel, 3D-Druck nötig
Drehtrommel (Kammerrad)28BYJ-48 SchrittmotorHoch, entspricht dem KammervolumenMittel
SchieberMG996R ServoMittelEinfach bis mittel
DS1307 RTC-Uhrmodul
DS1307-RTC-Modul: Liefert Uhrzeit und Datum per I2C und vergisst dank der CR2032 auf der Rückseite die Zeit auch bei Stromausfall nicht.

Schaltplan: Pins für Arduino Uno, ESP32 und Pico

Bauteil / PinArduino UnoESP32Raspberry Pi Pico
Servo-Signal (orange)D9GPIO 18GP15
Servo VCC (rot)Externe 5 VExterne 5 VExterne 5 V
Servo GND (braun)GND (gemeinsam)GND (gemeinsam)GND (gemeinsam)
Futter-TasterD2 – GNDGPIO 25 – GNDGP14 – GND
Portions-TasterD3 – GNDGPIO 26 – GNDGP13 – GND
Aktiver Buzzer (+)D8GPIO 27GP16
RTC / LCD SDAA4Nicht nötig (NTP)GP4 (DS3231)
RTC / LCD SCLA5Nicht nötig (NTP)GP5 (DS3231)
RTC VCC5V (DS1307)—3V3 (DS3231)
Versorge den Servo nicht über den 5V-Pin des Arduino. Ein SG90 kann bei blockierter Klappe kurzzeitig mehrere hundert Milliampere ziehen; die Spannung bricht ein, der Arduino startet neu oder die RTC liefert Unsinn. Nimm ein separates 5-V-Netzteil und verbinde dessen GND unbedingt mit dem GND des Arduino. Außerdem braucht der DS1307 mindestens 4,5 V; bei 3,3-V-Boards wie ESP32 und Pico nimmst du den DS3231, der auch mit 3,3 V läuft.

Aufbau Schritt für Schritt

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

AbschnittWas 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 / sonBeslemeStellt 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 / oncekiPorsErkennt 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.

Statt die Klappe einmal lange zu öffnen, macht häufiges kurzes Öffnen die Portion gleichmäßiger und verringert die Gefahr, dass das Futter an der Öffnung eine Brücke bildet und klemmt. Klemmt es trotzdem, hilft eine kleine Rüttelbewegung von 50 ms vor dem Schließen der Klappe.

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.

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

MicroPython
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 debounce

Tipps 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

ProblemMögliche UrsacheLösung
Arduino startet neu, wenn sich der Servo bewegtServo hängt am 5V-Pin der PlatineExternes 5-V-2-A-Netzteil nutzen, GNDs verbinden
Zur Futterzeit leert sich der ganze BehälterIn derselben Minute wird wiederholt gefüttertDie Prüfung anahtar / sonBesleme im Code beibehalten
Uhr springt bei jedem Start auf die KompilierzeitRTC-Batterie fehlt oder ist leerCR2032 tauschen, Kontakte des Batteriehalters prüfen
LCD zeigt keinen Text, nur KästchenKontrast falsch oder falsche I2C-AdresseDas 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 ZustandKlappe sitzt nicht richtig, Servo korrigiert ständigKAPALI-Winkel um ein paar Grad ändern oder nach der Bewegung kapak.detach() nutzen
ESP32 füttert gar nichtNTP noch nicht synchronisiert oder kein WLANVerbindung im Seriellen Monitor prüfen; der Code wartet, bis die Zeit da ist
Bevor du den Automaten im Alltag einsetzt, stelle die Futterzeiten eine Stunde lang im Minutenabstand ein, teste ihn und wiege jede Portion. Nutze ihn in den ersten Tagen zusammen mit Mahlzeiten, die du selbst gibst; das Tier braucht meist ein paar Tage, um den Buzzer-Ton mit Futter zu verbinden, und gewöhnt sich so leichter an die neue Routine.

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.

Alle Projekte ansehen
LED mit Taster ein- und ausschalten
AR-10Anfänger

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.

4.7(103)
177
Verwendung von Servomotoren
AR-35Anfänger
Premium

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.

4.7(48)
67
DS1302-RTC-Uhrenmodul einrichten
AR-45Anfänger

DS1302-RTC-Uhrenmodul einrichten

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

4.5(23)
31
DS1302 RTC-Uhr mit LCD-Anzeige
AR-46Mittel
Premium

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…

4.7(41)
51
Digitale Uhr mit ESP32 und RTC DS1307 (I2C + LCD)
ES-18Mittel
Premium

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.

4.6(26)
40
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

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.

4.5(13)
22
ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
ES-41Fortgeschritten
Premium

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.

9