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.

¿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.
| Material | Función | Nota |
|---|---|---|
| Arduino Uno (o Nano) | Placa de control principal | Con Nano la carcasa es más pequeña |
| Servomotor SG90 | Abre y cierra la tapa | MG90S o MG996R para tapas pesadas |
| Módulo RTC DS1307 | Guarda la hora y la fecha | La pila CR2032 conserva la hora; necesita 5 V |
| 2 pulsadores | Alimentación manual y elección de ración | Usa el pull-up interno, no hace falta resistencia |
| Zumbador activo | Señal de comida | El animal acaba acostumbrándose al sonido |
| LCD 16x2 I2C | Muestra la hora y la ración | Dirección habitual 0x27 o 0x3F |
| Adaptador de 5 V 2 A | Alimenta el servo y la placa | No alimentes el servo desde el USB |
| Tolva, embudo y carcasa | Contienen y guían el pienso | Botella 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.
| Mecanismo | Motor | Consistencia de la ración | Dificultad |
|---|---|---|---|
| Tolva con tapa de servo | SG90 / MG90S | Media, varía según el tamaño de la croqueta | Fácil |
| Tornillo sin fin | Servo de rotación continua FS90R o motor paso a paso 28BYJ-48 | Alta | Media, requiere impresión 3D |
| Tambor giratorio (rueda con compartimentos) | Motor paso a paso 28BYJ-48 | Alta, según el volumen del compartimento | Media |
| Compuerta deslizante | Servo MG996R | Media | Fácil–media |

Esquema de conexión: pines de Arduino Uno, ESP32 y Pico
| Pieza / pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Señal del servo (naranja) | D9 | GPIO 18 | GP15 |
| VCC del servo (rojo) | 5 V externos | 5 V externos | 5 V externos |
| GND del servo (marrón) | GND (común) | GND (común) | GND (común) |
| Botón de comida | D2 – GND | GPIO 25 – GND | GP14 – GND |
| Botón de ración | D3 – GND | GPIO 26 – GND | GP13 – GND |
| Zumbador activo (+) | D8 | GPIO 27 | GP16 |
| SDA del RTC / LCD | A4 | No hace falta (NTP) | GP4 (DS3231) |
| SCL del RTC / LCD | A5 | No hace falta (NTP) | GP5 (DS3231) |
| VCC del RTC | 5V (DS1307) | — | 3V3 (DS3231) |
Montaje paso a paso
- 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.
- 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).
- 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.
- 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.
- 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.
- 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.
- 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.
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 / sonBesleme | Garantiza 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 / oncekiPors | Detectan 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.
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.
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.
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 debounceConsejos 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
| Problema | Causa probable | Solución |
|---|---|---|
| Arduino se reinicia cuando se mueve el servo | El servo se alimenta desde el pin 5V de la placa | Usa un adaptador externo de 5 V 2 A y une los GND |
| A la hora de comer la tolva se vacía por completo | Se sirve repetidamente dentro del mismo minuto | Mantén la comprobación de anahtar / sonBesleme del código |
| La hora vuelve a la de compilación en cada arranque | El RTC no tiene pila o está agotada | Cambia la pila CR2032 y revisa los contactos del portapilas |
| La LCD solo muestra cuadraditos, sin texto | Contraste mal ajustado o dirección I2C incorrecta | Gira el potenciómetro trasero y prueba la dirección 0x3F |
| El pienso se atasca en la salida | Salida estrecha o poca inclinación | Ensancha la salida, aumenta la inclinación y añade una sacudida a la tapa |
| El servo zumba y vibra cuando está cerrado | La tapa no asienta bien y el servo corrige constantemente | Cambia el ángulo KAPALI unos grados o usa kapak.detach() tras el movimiento |
| El ESP32 no sirve nada | NTP aún no se ha sincronizado o no hay Wi-Fi | Revisa la conexión en el Monitor serie; el código espera a tener la hora |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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…

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.

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

