Guías · 10 min de lectura

Comedero Automático Arduino: Dispensador de Comida con Reloj

Haz un comedero automático con Arduino: tolva con tapa servo, horario con RTC DS1307, ajuste de ración con botón, panel web con ESP32 y aviso por Telegram.

Un comedero automático es un pequeño dispensador electrónico que da a tu gato o perro la cantidad de pienso seco que tú decidas, a las horas que tú decidas. Para hacer un comedero automático con Arduino necesitas una tolva para el pienso, un servomotor que abra y cierre la salida, un módulo RTC (reloj de tiempo real) que no pierda la hora y dos botones para ajustar la ración. El coste total es una fracción del de un comedero comercial, y tú controlas a qué hora y cuánto se sirve.

En esta guía montaremos primero la versión básica con Arduino Uno: tres comidas al día con un RTC DS1307, una tolva con tapa de servo SG90, un botón para dar de comer al instante, otro para elegir la ración de 1 a 5 y un reloj en una pantalla LCD I2C. Después verás la versión con ESP32, donde cambias los horarios desde el navegador del móvil y recibes un aviso de Telegram en cada comida, y por último el mismo programa con Raspberry Pi Pico y MicroPython. Al final hay consejos de montaje para que el pienso no se atasque, el animal no tire la máquina y la carcasa sea resistente.

Servomotor SG90 como tapa de un comedero automático
Microservo SG90: abre y cierra la tapa de la tolva entre 0° y 80° para soltar la ración.

¿Qué es un comedero automático y cómo funciona?

La lógica es muy sencilla: el pienso espera en una tolva superior y baja por gravedad hacia una salida estrecha. Una tapa unida a un servomotor cierra esa salida. En cada vuelta del bucle, Arduino lee la hora del módulo RTC; cuando coincide con una de las horas de comida de la lista, el servo abre la tapa un instante, el pienso cae al plato y la tapa se cierra de nuevo. El número de aperturas determina la ración. Gracias a la pila de botón del módulo RTC, la hora no se pierde aunque se vaya la luz, y al volver la corriente la máquina sigue sirviendo a la hora correcta. Los botones sirven para dar de comer a mano y ajustar la ración, y el zumbador emite una señal corta antes de cada comida.

MaterialFunciónNota
Arduino Uno (o Nano)Placa de control principalCon Nano la carcasa es más pequeña
Servomotor SG90Abre y cierra la tapaMG90S o MG996R para tapas pesadas
Módulo RTC DS1307Guarda la hora y la fechaLa pila CR2032 conserva la hora; necesita 5 V
2 pulsadoresAlimentación manual y elección de raciónUsa el pull-up interno, no hace falta resistencia
Zumbador activoSeñal de comidaEl animal acaba acostumbrándose al sonido
LCD 16x2 I2CMuestra la hora y la raciónDirección habitual 0x27 o 0x3F
Adaptador de 5 V 2 AAlimenta el servo y la placaNo alimentes el servo desde el USB
Tolva, embudo y carcasaContienen y guían el piensoBotella PET, caja de almacenaje, foam PVC o impresión 3D

Elegir el mecanismo: tapa, tornillo sin fin o tambor giratorio

El corazón del comedero es el mecanismo que suelta el pienso, y esta elección afecta tanto al código como a la carcasa. Para empezar, lo más fácil es la tolva con tapa de servo: una tapa atornillada al brazo del servo cierra la salida y, al abrirse, el pienso cae. Si quieres una ración más precisa, puedes usar un tornillo sin fin o un tambor giratorio con compartimentos; como transportan el pienso por volumen, en cada giro cae casi la misma cantidad, pero requieren impresión 3D o una mecánica más cuidada.

MecanismoMotorConsistencia de la raciónDificultad
Tolva con tapa de servoSG90 / MG90SMedia, varía según el tamaño de la croquetaFácil
Tornillo sin finServo de rotación continua FS90R o motor paso a paso 28BYJ-48AltaMedia, requiere impresión 3D
Tambor giratorio (rueda con compartimentos)Motor paso a paso 28BYJ-48Alta, según el volumen del compartimentoMedia
Compuerta deslizanteServo MG996RMediaFácil–media
Módulo de reloj RTC DS1307
Módulo RTC DS1307: da la hora y la fecha por I2C y, gracias a la pila CR2032 de la parte trasera, no pierde la hora si se va la luz.

Esquema de conexión: pines de Arduino Uno, ESP32 y Pico

Pieza / pinArduino UnoESP32Raspberry Pi Pico
Señal del servo (naranja)D9GPIO 18GP15
VCC del servo (rojo)5 V externos5 V externos5 V externos
GND del servo (marrón)GND (común)GND (común)GND (común)
Botón de comidaD2 – GNDGPIO 25 – GNDGP14 – GND
Botón de raciónD3 – GNDGPIO 26 – GNDGP13 – GND
Zumbador activo (+)D8GPIO 27GP16
SDA del RTC / LCDA4No hace falta (NTP)GP4 (DS3231)
SCL del RTC / LCDA5No hace falta (NTP)GP5 (DS3231)
VCC del RTC5V (DS1307)—3V3 (DS3231)
No alimentes el servo desde el pin 5V de Arduino. Cuando la tapa hace esfuerzo, un SG90 puede consumir cientos de miliamperios de golpe; la tensión de la placa cae, Arduino se reinicia o el RTC lee valores absurdos. Alimenta el servo con un adaptador de 5 V aparte y une siempre el GND del adaptador al GND de Arduino. Además, el DS1307 necesita al menos 4,5 V; en placas de 3,3 V como ESP32 y Pico usa el DS3231, que también funciona a 3,3 V.

Montaje paso a paso

  1. En el Arduino IDE, instala desde el Gestor de bibliotecas RTClib (Adafruit) y LiquidCrystal I2C (Frank de Brabander); la biblioteca Servo viene incluida con el IDE.
  2. Conecta el módulo RTC y la LCD al mismo bus I2C (A4 = SDA, A5 = SCL); no chocan porque tienen direcciones distintas (0x68 y 0x27).
  3. Conecta el cable de señal del servo a D9 y los cables rojo y marrón al adaptador externo de 5 V; une el GND del adaptador con el GND de Arduino.
  4. Conecta una pata de cada botón a D2 y D3 y la otra a GND. En el código se usa INPUT_PULLUP, así que no hace falta resistencia externa.
  5. Pon la pila CR2032 en el RTC y sube el código. Si el RTC nunca se ha configurado, la hora se ajusta a la del ordenador en el momento de compilar.
  6. Antes de montar el brazo del servo, espera a que el código lo lleve a 0° y atornilla el brazo con la tapa cerrada. Así los ángulos ACIK y KAPALI encajan exactamente con tu mecanismo.
  7. Coloca un recipiente bajo la tolva, pulsa el botón de comida varias veces y pesa el pienso que cae para calibrar la ración.
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}

¿Cómo funciona el código?

Sección¿Qué hace?
ogunler[][2]Guarda las horas de comida como pares hora-minuto; añade filas para tener más comidas.
mamaVer(adet)Hace sonar el zumbador y abre y cierra la tapa 400 ms tantas veces como indique la ración.
anahtar / sonBeslemeGarantiza que la comida se sirva solo una vez aunque el bucle se ejecute cientos de veces en el mismo minuto.
rtc.isrunning()Si el RTC nunca se ha configurado o se ha quedado sin pila, ajusta la hora a la de compilación.
oncekiBesle / oncekiPorsDetectan el instante de la pulsación (flanco de bajada), no que el botón siga pulsado.
ekranYaz()Actualiza la LCD una vez por segundo; escribirla en cada vuelta provoca parpadeo y lentitud.

La línea más importante del código es la clave de comida. La función loop de Arduino se ejecuta decenas de veces por segundo, así que a las 08:00 la condición se cumple muchas veces durante ese minuto. Con una simple comparación, la máquina vaciaría toda la tolva en ese minuto. Por eso convertimos día, hora y minuto en un solo número: día × 1440 + hora × 60 + minuto. Si coincide con el de la última comida, ya se ha servido. Incluir el día también hace que, aunque haya una sola comida en la lista, se vuelva a servir a la misma hora al día siguiente.

Calibrar la ración: ¿cuántos gramos caen?

En una tolva con tapa de servo, la cantidad que cae depende del tiempo que la tapa está abierta, del diámetro de la salida y del tamaño de la croqueta. Por eso la ración se mide, no se calcula. Pon un recipiente vacío sobre una báscula de cocina, pulsa el botón de comida 10 veces con la ración en 1 y divide el peso total entre 10: ese número es la media de gramos por apertura. Por ejemplo, si en 10 aperturas caen 120 g, cada una son unos 12 g. Si tu gato necesita 60 g al día en tres comidas, son 20 g por comida; eso significa poner la ración en 2 (unos 24 g) o reducir un poco los 400 ms de apertura. Fija la cantidad diaria según la tabla del paquete de pienso y la recomendación de tu veterinario.

En lugar de abrir la tapa una vez durante mucho tiempo, abrirla muchas veces y brevemente da una ración más constante y reduce que el pienso forme un puente en la salida y se atasque. Si tienes atascos, también ayuda añadir un pequeño movimiento de sacudida de 50 ms antes de cerrar la tapa.

Versión ESP32: horarios desde la web y aviso por Telegram

El ESP32 aporta dos grandes ventajas al comedero. La primera: como obtiene la hora de internet (NTP), no necesitas módulo RTC y la hora no se desvía. La segunda: puede ejecutar su propio servidor web, así que cambias las horas y la ración desde el navegador del móvil conectado a la misma red Wi-Fi. Después de cada comida te llega a Telegram el mensaje "Comida servida", y así sabes que tu mascota ha comido aunque estés fuera de casa. Para compilar el código instala desde el Gestor de bibliotecas UniversalTelegramBot y ArduinoJson, que esta utiliza. El token del bot lo obtienes con BotFather en Telegram y el chat ID, después de enviar un mensaje a tu bot; tienes los detalles en el artículo Bot de Telegram con ESP32.

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}

En este código no usamos ninguna biblioteca para el servo; generamos la señal de 50 Hz y 14 bits con el periférico PWM por hardware LEDC del ESP32. Un pulso de 500–2400 microsegundos equivale a 0–180 grados. Como en la versión 3.x del núcleo Arduino para ESP32 cambiaron las funciones LEDC, las dos versiones se separan con ESP_ARDUINO_VERSION_MAJOR, y el código compila tanto con 2.x como con 3.x. Las horas y la ración se guardan en la memoria flash con Preferences, por lo que no se pierden si se va la luz. Abre en el navegador la IP del ESP32 (aparece en el Monitor serie), elige las horas y pulsa Guardar. La zona horaria está configurada en UTC+3 (Turquía); si estás en otro país, cambia la cadena de la línea configTzTime. Para más detalles sobre NTP, mira el artículo Reloj NTP con ESP32.

Comedero automático con Raspberry Pi Pico y MicroPython

La Pico también tiene una unidad de reloj interna, pero se reinicia al cortarse la corriente, así que un RTC con pila es imprescindible. Como la Pico funciona a 3,3 V, usa un DS3231 en lugar del DS1307: tiene la misma dirección 0x68 y los mismos registros de hora, y gracias a su cristal compensado por temperatura solo se desvía alrededor de un minuto al año. El código siguiente no necesita bibliotecas adicionales: lee el RTC directamente por I2C y mueve el servo con PWM a 50 Hz. Para poner la hora por primera vez, quita el comentario de la línea set_time, ejecuta el código una vez y vuelve a comentarla.

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

Consejos para la maqueta y la carcasa

  • Tolva: sirve una botella PET de 1,5 litros o una caja de almacenaje con tapa. Con tapa, el pienso queda protegido de la humedad y de patas curiosas; en las piezas que tocan el pienso usa plástico apto para alimentos.
  • Inclinación del fondo: el fondo de la tolva debe tener al menos 45 grados de inclinación. Con fondos más planos el pienso se queda en las esquinas y las últimas comidas salen incompletas.
  • Salida: las croquetas secas suelen medir 8–15 mm; haz la salida de 25–35 mm. Una boca muy estrecha provoca atascos y una muy ancha hace que se aplasten croquetas al cerrar la tapa.
  • Tapa: usa una placa de foam PVC, cartón pluma o impresa en 3D y fíjala al brazo del servo con un tornillo M2. El pegamento solo acaba aflojándose con el tiempo.
  • Base resistente: gatos y perros empujan y tratan de volcar la máquina para llegar al pienso. Haz la base ancha, añade peso debajo o fija la carcasa a la pared.
  • Seguridad de los cables: cubre el cable del adaptador con protector en espiral y mete la electrónica en una caja cerrada; un cable mordido es peligroso tanto para el animal como para el aparato.
  • Circuito permanente: la protoboard puede aflojarse con las vibraciones. Suelda el circuito que funciona sobre una placa perforada.

Ideas para mejorar el comedero

  • Plato con peso: mide el peso del plato con un HX711 y una célula de carga; si el plato aún está lleno no sirvas otra ración, y dosifica con precisión en gramos.
  • Aviso de tolva vacía: el sensor de nivel sin contacto XKC-Y25 se pega por fuera de la tolva y te avisa por Telegram cuando queda poco pienso.
  • Notificación con foto: con una ESP32-CAM envía a tu móvil una foto de tu mascota comiendo en cada comida.
  • Bebedero automático: con una mini bomba de agua y un sensor de nivel, rellena también el bebedero por sí solo.
  • Llamada por voz: con un DFPlayer Mini reproduce a la hora de comer una llamada grabada con tu propia voz.
  • Guardar los ajustes: en la versión de Arduino, guarda la ración en la EEPROM para que no vuelva al valor por defecto cuando se vaya la luz.

Errores frecuentes y cómo solucionarlos

ProblemaCausa probableSolución
Arduino se reinicia cuando se mueve el servoEl servo se alimenta desde el pin 5V de la placaUsa un adaptador externo de 5 V 2 A y une los GND
A la hora de comer la tolva se vacía por completoSe sirve repetidamente dentro del mismo minutoMantén la comprobación de anahtar / sonBesleme del código
La hora vuelve a la de compilación en cada arranqueEl RTC no tiene pila o está agotadaCambia la pila CR2032 y revisa los contactos del portapilas
La LCD solo muestra cuadraditos, sin textoContraste mal ajustado o dirección I2C incorrectaGira el potenciómetro trasero y prueba la dirección 0x3F
El pienso se atasca en la salidaSalida estrecha o poca inclinaciónEnsancha la salida, aumenta la inclinación y añade una sacudida a la tapa
El servo zumba y vibra cuando está cerradoLa tapa no asienta bien y el servo corrige constantementeCambia el ángulo KAPALI unos grados o usa kapak.detach() tras el movimiento
El ESP32 no sirve nadaNTP aún no se ha sincronizado o no hay Wi-FiRevisa la conexión en el Monitor serie; el código espera a tener la hora
Antes de usar la máquina de verdad, pon las horas de comida con un minuto de diferencia, pruébala durante una hora y pesa cada ración. Los primeros días combina el comedero con comidas dadas a mano; el animal suele tardar unos días en asociar el sonido del zumbador con la comida, y así se acostumbra más fácilmente a la nueva rutina.

El comedero automático reúne en un solo proyecto real conceptos básicos como servo, RTC, botones y Wi-Fi, por lo que es muy valioso tanto como proyecto de clase como para un aparato que de verdad se use en casa. Para más detalles sobre el servo y el RTC, echa un vistazo a los artículos servomotor y módulo de reloj RTC. En la app de BlueGrays encontrarás, con esquemas y código paso a paso, proyectos de uso de servos, reloj con RTC, ESP32 NTP y alarmas con aviso de Telegram, para probar cada parte de este comedero por separado.

Preguntas frecuentes

¿Qué servo uso para un comedero automático?

Para una tapa ligera el SG90 basta y es la opción más barata. Si la tapa es pesada, la tolva grande o el pienso presiona la tapa, elige un MG90S o MG996R con engranajes metálicos. Para mecanismos de tornillo sin fin o tambor giratorio es mejor un servo de rotación continua FS90R o un motor paso a paso 28BYJ-48.

¿El comedero pierde la hora si se va la luz?

No: la pila CR2032 del módulo RTC conserva la hora y, al volver la corriente, la máquina sigue sirviendo a la hora correcta. Eso sí, la comida que coincida con el corte se salta. La versión con ESP32 recupera la hora por NTP en cuanto se reconecta al Wi-Fi.

¿Cuántas comidas al día puede dar un comedero con Arduino?

Puedes definir tantas como quieras añadiendo filas al array ogunler del código. La memoria del Arduino Uno sobra para decenas de comidas. El límite práctico es la necesidad diaria de tu mascota y el reparto que recomiende tu veterinario.

¿Puede funcionar el comedero con una batería externa o pilas?

Por poco tiempo, sí; una batería externa con salida de 5 V es lo más práctico. Como Arduino Uno y la LCD consumen unos 60–70 mA juntos, una batería de 10000 mAh dura aproximadamente 3–4 días. Algunas baterías se apagan solas con corrientes bajas, así que para uso prolongado un adaptador de 5 V es más fiable.

¿Puedo controlar el comedero ESP32 desde fuera de casa?

El panel web del ejemplo solo funciona dentro de la misma red Wi-Fi. Para controlarlo desde fuera puedes hacer que el bot de Telegram escuche comandos como /besle, o usar un servicio en la nube como MQTT o Blynk. Abrir puertos en el router no se recomienda por seguridad.

¿Se puede usar un comedero automático con comida húmeda?

La tolva con tapa de servo es solo para pienso seco; la comida húmeda no fluye, se acumula en la tapa y se estropea rápido. Para comida húmeda hacen falta diseños donde cada ración espere en un compartimento separado cuya tapa abra el servo a su hora, preferiblemente refrigerado con un pack de hielo.

Ver todos los proyectos
Encender y apagar un LED con un botón
AR-10Principiante

Encender y apagar un LED con un botón

Pulsas el botón una vez y la luz se enciende, lo pulsas otra vez y se apaga, igual que el interruptor de tu habitación.

4.7(103)
177
Uso del servomotor
AR-35Principiante
Premium

Uso del servomotor

El brazo de un pequeño servomotor gira por turnos a tres posiciones: al principio del todo, justo al centro y al final del todo, esperando dos segundos en cada parada.

4.7(48)
67
Configuración del módulo de reloj RTC DS1302
AR-45Principiante

Configuración del módulo de reloj RTC DS1302

Pones en marcha un pequeño módulo de reloj que no olvida la hora aunque el Arduino se apague.

4.5(23)
31
Reloj RTC DS1302 con pantalla LCD
AR-46Intermedio
Premium

Reloj RTC DS1302 con pantalla LCD

Un pequeño reloj de mesa que no pierde la hora aunque se vaya la luz. El módulo de reloj DS1302 guarda la hora gracias a su propia pila diminuta; cada segundo el Arduino la lee y escribe la hora y la…

4.7(41)
51
Reloj digital con ESP32 y RTC DS1307 (I2C + LCD)
ES-18Intermedio
Premium

Reloj digital con ESP32 y RTC DS1307 (I2C + LCD)

En este proyecto, mostramos la hora y la fecha en una pantalla LCD I2C de 16x2 mediante el módulo de reloj en tiempo real (RTC) DS1307. El DS1307 es un RTC con batería de respaldo que conserva la hora incluso si el ESP32 se apaga. Ambos módulos comparten la misma línea I2C (SDA/SCL), por lo que aprendemos a controlar varios dispositivos con solo dos cables de señal. Con este proyecto conocerás el protocolo I2C, el funcionamiento de los módulos RTC y la visualización dinámica en pantallas LCD.

4.6(26)
40
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

ESP32: hora real desde Internet con NTP

El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

4.5(13)
22
Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzado
Premium

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)

Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.

9