Guias · 11 min de leitura

Alimentador automático para pets com Arduino: comedouro com horários programados

Monte um alimentador automático para pets com Arduino: reservatório com tampa servo, refeições no horário com RTC DS1307, botão de porção, painel web no ESP32 e avisos no Telegram, além de código para Pico.

Um alimentador automático para pets é um pequeno dispositivo eletrônico que libera ração seca para seu gato ou cachorro nos horários e nas quantidades que você escolher. Para montar um alimentador automático com Arduino, você precisa de um reservatório de ração, um servo motor que abre e fecha a saída do reservatório, um módulo RTC (relógio de tempo real) que nunca esquece a hora e dois botões para ajustar a porção. O custo total é uma pequena fração de um alimentador comercial pronto, e você decide exatamente a que horas e quanta ração será servida.

Neste guia, primeiro montamos a versão básica com um Arduino Uno: três refeições por dia com um RTC DS1307, um reservatório com tampa acionada por um servo SG90, um botão para alimentar na hora, outro para escolher uma porção de 1 a 5 e um relógio em um LCD I2C. Depois, na versão com ESP32, você vai mudar os horários das refeições pelo navegador do celular e receber uma notificação no Telegram a cada refeição e, por fim, vai ver a mesma lógica escrita com um Raspberry Pi Pico e MicroPython. No final, também há dicas de montagem para a ração não entupir, o pet não conseguir derrubar a máquina e a estrutura ficar firme.

Servo motor SG90 para a tampa do alimentador automático para pets
Micro servo SG90: libera a porção abrindo e fechando a tampa do reservatório entre 0° e 80°.

O que é um alimentador automático para pets e como funciona?

A lógica do sistema é muito simples: a ração fica em um reservatório na parte de cima e desce por gravidade até uma saída estreita embaixo. Uma tampa presa a um servo motor fecha essa saída. A cada ciclo, o Arduino lê a hora no módulo RTC; quando a hora coincide com um dos horários de refeição da lista, o servo abre a tampa por um instante, a ração cai no pote e a tampa fecha de novo. O número de vezes que a tampa abre define a porção. Graças à bateria tipo moeda no módulo RTC, a hora não se perde mesmo se faltar energia; quando a máquina volta a ter alimentação, continua servindo no horário certo. Os botões servem para alimentar manualmente e ajustar a porção, e o buzzer dá um sinal curto antes de cada refeição.

ComponenteFunçãoObservação
Arduino Uno (ou Nano)Placa controladora principalCom um Nano a estrutura fica menor
Servo motor SG90Abre e fecha a tampaMG90S ou MG996R para uma tampa pesada
Módulo RTC DS1307Guarda a hora e a dataA bateria CR2032 mantém a hora durante quedas de energia; precisa de 5 V
2 botões de pressãoAlimentação manual e escolha da porçãoUsa o pull-up interno, não precisa de resistor
Buzzer ativoSinal da refeiçãoCom o tempo, o pet se acostuma com o som
LCD I2C 16x2Mostra a hora e a porçãoO endereço geralmente é 0x27 ou 0x3F
Fonte 5 V 2 AAlimenta o servo e a placaNão alimente o servo pela USB
Reservatório, funil, estruturaArmazena e direciona a raçãoGarrafa PET, pote organizador, PVC expandido ou impressão 3D

Escolhendo o mecanismo: reservatório com tampa, rosca sem fim ou tambor rotativo

O coração do alimentador é o mecanismo que libera a ração, e essa escolha afeta tanto o código quanto a estrutura. O método mais fácil para iniciantes é o reservatório com tampa acionada por servo: uma tampa parafusada na ponta do braço do servo fecha a saída e, quando a tampa abre, a ração escorre. Se você quiser porções mais precisas, pode usar uma rosca sem fim (helicoide) ou um tambor rotativo com compartimentos; esses mecanismos transportam a ração por volume, então cai quase a mesma quantidade a cada volta, mas exigem impressão 3D ou um trabalho mecânico mais cuidadoso.

MecanismoMotorConsistência da porçãoDificuldade
Reservatório com tampa servoSG90 / MG90SMédia, varia com o tamanho dos grãosFácil
Rosca sem fim (helicoide)Servo de rotação contínua FS90R ou motor de passo 28BYJ-48AltaMédia, exige impressão 3D
Tambor rotativo (roda com compartimentos)Motor de passo 28BYJ-48Alta, igual ao volume do compartimentoMédia
Comporta deslizanteServo MG996RMédiaFácil a média
Módulo relógio RTC DS1307
Módulo RTC DS1307: fornece hora e data via I2C e, graças à bateria CR2032 na parte de trás, não esquece a hora nem quando falta energia.

Esquema de ligação: pinos do Arduino Uno, ESP32 e Pico

Componente / pinoArduino UnoESP32Raspberry Pi Pico
Sinal do servo (laranja)D9GPIO 18GP15
VCC do servo (vermelho)5 V externo5 V externo5 V externo
GND do servo (marrom)GND (comum)GND (comum)GND (comum)
Botão de alimentarD2 – GNDGPIO 25 – GNDGP14 – GND
Botão de porçãoD3 – GNDGPIO 26 – GNDGP13 – GND
Buzzer ativo (+)D8GPIO 27GP16
SDA do RTC / LCDA4Não precisa (NTP)GP4 (DS3231)
SCL do RTC / LCDA5Não precisa (NTP)GP5 (DS3231)
VCC do RTC5V (DS1307)—3V3 (DS3231)
Não alimente o servo pelo pino 5V do Arduino. Quando a tampa está sob esforço, um SG90 pode puxar por um instante centenas de miliampères; a tensão da placa cai, o Arduino reinicia ou o RTC lê valores sem sentido. Alimente o servo com uma fonte de 5 V separada e não deixe de ligar o GND da fonte ao GND do Arduino. Além disso, o DS1307 precisa de pelo menos 4,5 V; em placas de 3,3 V, como o ESP32 e o Pico, use o DS3231, que também funciona com 3,3 V.

Montagem passo a passo

  1. No Gerenciador de Bibliotecas do Arduino IDE, instale a RTClib (Adafruit) e a LiquidCrystal I2C (Frank de Brabander); a biblioteca Servo já vem com a IDE.
  2. Ligue o módulo RTC e o LCD no mesmo barramento I2C (A4 = SDA, A5 = SCL); eles não entram em conflito porque os dois módulos têm endereços diferentes (0x68 e 0x27).
  3. Ligue o fio de sinal do servo no D9 e os fios vermelho e marrom na fonte externa de 5 V; una o GND da fonte ao GND do Arduino.
  4. Ligue um terminal de cada botão no D2 e no D3 e o outro terminal no GND. O código usa INPUT_PULLUP, então não precisa de resistor externo.
  5. Coloque a bateria CR2032 no RTC e carregue o código. Se o RTC nunca foi ajustado, a hora é definida como a hora do computador no momento em que o código foi compilado.
  6. Antes de encaixar o braço do servo, espere o código levar o servo a 0° e então parafuse o braço com a tampa na posição fechada. Assim, os ângulos de abertura (OPEN) e fechamento (CLOSED) se ajustam exatamente ao seu mecanismo.
  7. Coloque um pote embaixo do reservatório, faça alguns testes com o botão de alimentar e calibre a porção pesando a ração que cai.
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}

Como o código funciona?

ParteO que faz
ogunler[][2] (horários das refeições)Guarda os horários das refeições como pares hora-minuto; você pode adicionar mais refeições incluindo novas linhas.
mamaVer(adet) (servir a ração)Toca o buzzer e abre e fecha a tampa por 400 ms tantas vezes quanto o valor da porção.
anahtar / sonBesleme (controle de repetição)Garante que a refeição seja servida só uma vez, mesmo que o loop rode centenas de vezes dentro do mesmo minuto.
rtc.isrunning() (verifica o RTC)Se o RTC nunca foi ajustado ou a bateria acabou, define a hora como a hora da compilação.
oncekiBesle / oncekiPors (estado anterior dos botões)Detecta o momento em que o botão é pressionado (a borda de descida), e não o botão sendo mantido pressionado.
ekranYaz() (atualiza o display)Atualiza o LCD uma vez por segundo; escrever no display a cada ciclo causa cintilação e lentidão.

A linha mais crítica do código é a chave de alimentação. A função loop do Arduino roda dezenas de vezes por segundo; quando o relógio marca 08:00, a condição é verdadeira repetidas vezes durante todo aquele minuto. Se você usasse uma simples verificação de coincidência, a máquina esvaziaria todo o reservatório nesse único minuto. Por isso, convertemos o dia, a hora e o minuto em um único número: dia × 1440 + hora × 60 + minuto. Se esse número for igual ao da última alimentação, a refeição já foi servida. Levar o dia em conta também garante que a alimentação aconteça de novo no mesmo horário no dia seguinte, mesmo que haja só uma refeição na lista.

Calibração da porção: quantos gramas de ração caem?

Em um reservatório com tampa servo, a quantidade que cai depende de quanto tempo a tampa fica aberta, do diâmetro da saída e do tamanho dos grãos de ração. Por isso, é preciso medir a porção em vez de calculá-la. Coloque um pote vazio em uma balança de cozinha, pressione o botão de alimentar 10 vezes com a porção em 1 e divida o peso total por 10; esse número é a média de gramas por abertura da tampa. Por exemplo, se caem 120 g em 10 aberturas, uma abertura dá cerca de 12 g. Se o seu gato precisa de 60 g por dia em três refeições, cada refeição precisa de 20 g; isso significa ajustar a porção para 2 (cerca de 24 g) ou encurtar um pouco o tempo de abertura de 400 ms. Defina a quantidade diária com base na tabela da embalagem da ração e na recomendação do seu veterinário.

Abrir a tampa várias vezes por pouco tempo, em vez de uma vez só por muito tempo, deixa a porção mais consistente e reduz o empedramento e o entupimento da ração na saída. Se houver entupimento, acrescentar um pequeno movimento de vaivém de 50 ms antes de fechar a tampa também ajuda.

Versão com ESP32: horários pela web e notificações no Telegram

O ESP32 traz duas grandes facilidades ao alimentador. Primeiro, como ele pega a hora da internet (NTP), você não precisa de um módulo RTC e a hora não atrasa. Segundo, como ele pode rodar o próprio servidor web, você pode mudar os horários das refeições e a porção pelo navegador do celular na mesma rede Wi-Fi. Depois de cada alimentação, chega uma mensagem “Food served” (ração servida) no Telegram; assim, mesmo longe de casa, você sabe que seu pet comeu. Para compilar o código, instale pelo Gerenciador de Bibliotecas a UniversalTelegramBot e a biblioteca ArduinoJson, que ela usa. Você obtém o token do bot com o BotFather no Telegram e o seu chat ID depois de mandar uma mensagem para o seu bot; os detalhes estão no post Bot do Telegram com 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}

Neste código não usamos uma biblioteca separada para o servo; geramos um sinal de 50 Hz e 14 bits com a unidade de PWM por hardware LEDC do ESP32. Uma largura de pulso de 500–2400 microssegundos corresponde a 0–180 graus. Como as funções LEDC mudaram na versão 3.x do core do Arduino para ESP32, as duas versões são separadas com ESP_ARDUINO_VERSION_MAJOR; o código compila tanto com a 2.x quanto com a 3.x. Os horários das refeições e a porção são gravados na memória flash com Preferences, então não se perdem quando a energia cai e volta. Abra o endereço IP do ESP32 no navegador (ele aparece no Monitor Serial), escolha os horários e toque em Save (Salvar). O fuso horário está configurado como UTC+3 para a Turquia; se você estiver em outro país, mude a string na linha configTzTime. Para detalhes sobre NTP, veja o post relógio NTP com ESP32.

Alimentador para pets com Raspberry Pi Pico e MicroPython

O Pico também tem uma unidade de relógio interna, mas ela zera quando falta energia; por isso, um RTC com bateria é indispensável. Como o Pico trabalha com 3,3 V, use um DS3231 em vez do DS1307: ele usa o mesmo endereço 0x68 e os mesmos registradores de hora e, graças ao cristal com compensação de temperatura, atrasa só cerca de um minuto por ano. O código abaixo não precisa de biblioteca extra; ele lê o RTC diretamente via I2C e aciona o servo com PWM de 50 Hz. Para ajustar a hora pela primeira vez, basta remover o sinal de comentário no início da linha set_time, rodar o código uma vez e depois comentar a linha de novo.

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

Dicas de montagem e estrutura

  • Reservatório: uma garrafa PET de 1,5 litro ou um pote plástico com tampa já resolve. A tampa protege a ração da umidade e de patas curiosas; use plástico próprio para alimentos nas peças que encostam na ração.
  • Inclinação do fundo: o fundo do reservatório deve ter inclinação de pelo menos 45 graus. Com fundos mais planos, a ração fica nos cantos e as últimas refeições saem incompletas.
  • Saída: os grãos de ração seca costumam ter 8–15 mm; faça a saída com 25–35 mm. Uma saída estreita demais causa entupimento, e uma larga demais faz os grãos serem esmagados quando a tampa fecha.
  • Tampa: use uma placa de PVC expandido, placa de espuma (foam board) ou impressão 3D e prenda-a no braço do servo com um parafuso M2. Só cola acaba soltando com o tempo.
  • Base firme: gatos e cachorros empurram e tentam derrubar a máquina para chegar à ração. Faça a base larga, coloque peso embaixo ou fixe a estrutura na parede.
  • Segurança dos cabos: cubra o cabo da fonte com um protetor espiral e coloque a eletrônica em uma caixa fechada; um cabo roído é perigoso tanto para o animal quanto para o aparelho.
  • Circuito permanente: a protoboard pode se soltar com a vibração. Solde o circuito que já funciona em uma placa perfurada.

Ideias para melhorar seu alimentador para pets

  • Pote com balança: meça o peso do pote com um HX711 e célula de carga; não sirva uma nova porção se o pote ainda estiver cheio e alimente com precisão em gramas.
  • Aviso de reservatório vazio: um sensor de nível sem contato XKC-Y25 é colado do lado de fora do reservatório e avisa você no Telegram quando a ração estiver acabando.
  • Notificação com foto: com um ESP32-CAM, envie para o celular uma foto do seu pet comendo a cada refeição.
  • Bebedouro automático: encha o pote de água automaticamente com uma mini bomba d'água e um sensor de nível.
  • Chamada por voz: com um DFPlayer Mini, toque na hora da refeição um chamado gravado com a sua própria voz.
  • Salvar as configurações: na versão com Arduino, grave a porção na EEPROM para que ela não volte ao valor padrão quando faltar energia.

Erros comuns e como resolver

ProblemaCausa provávelSolução
O Arduino reinicia quando o servo se moveO servo está alimentado pelo pino 5V da placaUse uma fonte externa de 5 V 2 A e una os GNDs
O reservatório esvazia por completo na hora da refeiçãoA alimentação se repete dentro do mesmo minutoMantenha a verificação anahtar / sonBesleme no código
A hora volta para a hora da compilação toda vez que ligaBateria do RTC ausente ou descarregadaTroque a CR2032 e verifique os contatos do suporte da bateria
O LCD mostra só quadradinhos, sem textoAjuste de contraste ou endereço I2C erradoGire o potenciômetro atrás, tente o endereço 0x3F
A ração entope na saídaSaída estreita demais ou fundo com pouca inclinaçãoAlargue a saída, aumente a inclinação, adicione um movimento de vaivém à tampa
O servo zumbe e treme quando está fechadoA tampa não assenta totalmente e o servo fica corrigindoMude o ângulo de fechamento (CLOSED) em alguns graus ou use kapak.detach() depois do movimento
O ESP32 nunca serve raçãoO NTP ainda não sincronizou ou não há Wi-FiVerifique a conexão no Monitor Serial; o código foi feito para esperar até a hora chegar
Antes de colocar a máquina em uso de verdade, ajuste os horários das refeições com um minuto de intervalo, teste por uma hora e pese cada porção. Nos primeiros dias, use o alimentador junto com as refeições que você dá na mão; o pet costuma levar alguns dias para associar o som do buzzer à comida e, assim, se acostuma mais fácil com a nova rotina.

Um alimentador automático para pets junta conceitos básicos como servo, RTC, botões e Wi-Fi em um único projeto da vida real, por isso vale muito tanto como projeto escolar quanto como um aparelho que você vai realmente usar em casa. Para detalhes sobre servo e RTC, confira os posts servo motor e módulo relógio RTC. No app BlueGrays você encontra projetos de uso de servo, relógio com RTC, NTP no ESP32 e alarmes com notificação no Telegram, com esquema do circuito e código passo a passo, para testar cada parte deste alimentador separadamente.

Perguntas frequentes

Qual servo motor devo usar em um alimentador automático para pets?

Um SG90 basta para uma tampa leve e é a opção mais barata. Se a tampa for pesada, o reservatório for grande ou a ração fizer pressão sobre a tampa, escolha um MG90S ou MG996R com engrenagens de metal. Para mecanismos com rosca sem fim ou tambor rotativo, um servo de rotação contínua FS90R ou um motor de passo 28BYJ-48 é mais adequado.

O alimentador esquece a hora se faltar energia?

Graças à bateria CR2032 do módulo RTC, a hora é mantida e a máquina continua servindo no horário certo quando a energia volta. Porém, uma refeição que caia durante a queda de energia é pulada. A versão com ESP32 pega a hora da internet via NTP assim que se reconecta ao Wi-Fi.

Quantas refeições por dia um alimentador com Arduino pode servir?

Você pode definir quantas refeições quiser adicionando novas linhas ao array ogunler no código. A memória do Arduino Uno é mais do que suficiente para dezenas de refeições. O limite prático é a necessidade diária do seu pet e a rotina de refeições que o veterinário recomendar.

O alimentador funciona com power bank ou pilhas?

Por pouco tempo, sim; um power bank com saída de 5 V é a opção mais prática. Um Arduino Uno com LCD consome juntos cerca de 60–70 mA, então um power bank de 10,000 mAh dura aproximadamente 3–4 dias. Alguns power banks se desligam sozinhos com corrente baixa, por isso uma fonte de 5 V é mais confiável para uso prolongado.

Posso controlar o alimentador com ESP32 fora de casa?

O painel web do exemplo só funciona na mesma rede Wi-Fi. Para controle remoto, você pode adicionar ao bot do Telegram um recurso que escute comandos como /feed (alimentar) ou usar MQTT ou um serviço em nuvem como o Blynk. Abrir redirecionamento de portas no roteador não é recomendado por motivos de segurança.

Um alimentador automático pode ser usado com ração úmida?

Um reservatório com tampa servo serve só para ração seca; a ração úmida não escorre, acumula na tampa e estraga rápido. Para ração úmida, são necessários projetos em que cada refeição fica em um compartimento separado e a tampa do compartimento é aberta por um servo no horário programado, de preferência resfriado com gelo reutilizável (gelox).

Ver todos os projetos
Ligar e desligar um LED com botão
AR-10Iniciante

Ligar e desligar um LED com botão

Pressione o botão uma vez para acender a luz e outra vez para apagar, como o interruptor do seu quarto.

4.7(103)
177
Uso de servo motor
AR-35Iniciante
Premium

Uso de servo motor

O braço de um pequeno servo motor gira para três posições em sequência: o início, o meio e o fim do percurso, esperando dois segundos em cada parada.

4.7(48)
67
Configuração do módulo de relógio RTC DS1302
AR-45Iniciante

Configuração do módulo de relógio RTC DS1302

Coloque em funcionamento um pequeno módulo de relógio que mantém a hora mesmo quando o Arduino é desligado.

4.5(23)
31
Relógio RTC DS1302 com display LCD
AR-46Intermediário
Premium

Relógio RTC DS1302 com display LCD

Um pequeno relógio de mesa que mantém a hora mesmo quando falta energia. O módulo de relógio DS1302 mantém a hora graças à sua própria pilha; a cada segundo, o Arduino lê essa informação e exibe a…

4.7(41)
51
Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)
ES-18Intermediário
Premium

Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)

Neste projeto, exibimos a hora e a data em um display LCD I2C 16x2 usando o módulo de relógio de tempo real (RTC) DS1307. O DS1307 é um RTC com bateria de reserva que mantém a hora mesmo quando o ESP32 é desligado. Os dois módulos compartilham o mesmo barramento I2C (SDA/SCL), permitindo aprender a controlar vários dispositivos com apenas dois fios de sinal. Você aprenderá na prática o protocolo de comunicação I2C, o funcionamento dos módulos RTC e a exibição de dados dinâmicos em um LCD.

4.6(26)
40
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

Hora exata pela internet com ESP32 e NTP

O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

4.5(13)
22
Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
ES-41Avançado
Premium

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)

Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.

9