Distributore di Cibo Automatico Arduino: Guida con RTC e Servo
Costruisci un distributore di cibo automatico con Arduino: serbatoio con servo, orari con RTC, porzioni a pulsante, pannello web ESP32 e notifiche Telegram.
Un distributore di cibo automatico è un piccolo alimentatore elettronico che dà al tuo gatto o cane la quantità di crocchette che hai stabilito, agli orari che hai scelto. Per costruirlo con Arduino ti servono un serbatoio, un servo motore che apre e chiude la bocca di uscita, un modulo RTC (orologio in tempo reale) che non perde mai l'ora e due pulsanti per regolare la porzione. Il costo totale è una frazione di quello dei distributori commerciali e sei tu a decidere a che ora e quanto cibo dare.
In questa guida monteremo prima la versione base con Arduino Uno: tre pasti al giorno con RTC DS1307, serbatoio con sportello a servo SG90, un pulsante per l'erogazione immediata, un secondo pulsante per scegliere la porzione da 1 a 5 e l'ora su un display LCD I2C. Poi vedrai la versione ESP32, in cui cambi gli orari dal browser del telefono e ricevi una notifica Telegram a ogni pasto, e infine lo stesso progetto con Raspberry Pi Pico e MicroPython. In fondo trovi i consigli per costruire il modello: crocchette che non si bloccano, un animale che non ribalta la macchina e una struttura solida.

Cos'è un distributore di cibo automatico e come funziona?
La logica è semplicissima: il cibo resta nel serbatoio in alto e scende per gravità verso la stretta bocca di uscita, chiusa da uno sportello collegato al servo. A ogni ciclo Arduino legge l'ora dal modulo RTC; quando coincide con uno degli orari in elenco, il servo apre lo sportello per un attimo, il cibo cade nella ciotola e lo sportello si richiude. Il numero di aperture determina la porzione. La batteria a bottone del modulo RTC mantiene l'ora anche se manca la corrente, così al ritorno dell'alimentazione la macchina continua a dare da mangiare all'ora giusta. I pulsanti servono per l'erogazione manuale e per la porzione, mentre il buzzer emette un breve segnale prima di ogni pasto.
| Componente | Funzione | Nota |
|---|---|---|
| Arduino Uno (o Nano) | Scheda di controllo principale | Con il Nano la struttura è più piccola |
| Servo motore SG90 | Apre e chiude lo sportello | Per sportelli pesanti usa MG90S o MG996R |
| Modulo RTC DS1307 | Tiene ora e data | Con pila CR2032 l'ora resta salva senza corrente; richiede 5 V |
| 2 pulsanti | Erogazione manuale e scelta porzione | Pull-up interno, nessuna resistenza necessaria |
| Buzzer attivo | Segnale del pasto | L'animale con il tempo si abitua al suono |
| LCD 16x2 I2C | Mostra ora e porzione | Indirizzo di solito 0x27 o 0x3F |
| Alimentatore 5 V 2 A | Alimenta servo e scheda | Non alimentare il servo dall'USB |
| Serbatoio, imbuto, struttura | Contengono e guidano il cibo | Bottiglia PET, contenitore, PVC espanso o stampa 3D |
Scegliere il meccanismo: sportello, coclea o tamburo rotante
Il cuore del distributore è il meccanismo che rilascia il cibo, e la scelta influisce sia sul codice sia sulla struttura. Per chi inizia il metodo più facile è il serbatoio con sportello a servo: uno sportello avvitato al braccio del servo chiude la bocca di uscita e, quando si apre, il cibo scende. Per porzioni più precise puoi usare una coclea (vite senza fine) o un tamburo rotante a scomparti: trasportano il cibo a volume, quindi a ogni giro cade quasi la stessa quantità, ma richiedono stampa 3D o una meccanica più curata.
| Meccanismo | Motore | Costanza della porzione | Difficoltà |
|---|---|---|---|
| Serbatoio con sportello a servo | SG90 / MG90S | Media, dipende dalla dimensione delle crocchette | Facile |
| Coclea (vite senza fine) | Servo a rotazione continua FS90R o motore passo-passo 28BYJ-48 | Alta | Media, serve la stampa 3D |
| Tamburo rotante (ruota a scomparti) | Motore passo-passo 28BYJ-48 | Alta, pari al volume dello scomparto | Media |
| Cursore scorrevole | Servo MG996R | Media | Facile–media |

Schema dei collegamenti: pin di Arduino Uno, ESP32 e Pico
| Componente / pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Segnale servo (arancione) | D9 | GPIO 18 | GP15 |
| VCC servo (rosso) | 5 V esterni | 5 V esterni | 5 V esterni |
| GND servo (marrone) | GND (in comune) | GND (in comune) | GND (in comune) |
| Pulsante erogazione | D2 – GND | GPIO 25 – GND | GP14 – GND |
| Pulsante porzione | D3 – GND | GPIO 26 – GND | GP13 – GND |
| Buzzer attivo (+) | D8 | GPIO 27 | GP16 |
| SDA RTC / LCD | A4 | Non serve (NTP) | GP4 (DS3231) |
| SCL RTC / LCD | A5 | Non serve (NTP) | GP5 (DS3231) |
| VCC RTC | 5V (DS1307) | — | 3V3 (DS3231) |
Montaggio passo dopo passo
- Nel Gestore Librerie dell'Arduino IDE installa RTClib (Adafruit) e LiquidCrystal I2C (Frank de Brabander); la libreria Servo è già inclusa nell'IDE.
- Collega modulo RTC e LCD allo stesso bus I2C (A4 = SDA, A5 = SCL); non vanno in conflitto perché hanno indirizzi diversi (0x68 e 0x27).
- Collega il filo di segnale del servo a D9 e i fili rosso e marrone all'alimentatore esterno da 5 V; unisci il GND dell'alimentatore al GND di Arduino.
- Collega un capo dei pulsanti a D2 e D3 e l'altro a GND. Nel codice si usa INPUT_PULLUP, quindi non serve nessuna resistenza esterna.
- Inserisci la pila CR2032 nell'RTC e carica il codice. Se l'RTC non è mai stato impostato, l'ora viene regolata su quella del computer al momento della compilazione.
- Prima di montare il braccio del servo, aspetta che il codice lo porti a 0°, poi avvitalo con lo sportello chiuso. Così gli angoli ACIK e KAPALI si adattano perfettamente al tuo meccanismo.
- Metti una ciotola sotto il serbatoio, premi il pulsante di erogazione per qualche prova e pesa il cibo caduto per calibrare la porzione.
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}Come funziona il codice?
| Sezione | Cosa fa |
|---|---|
| ogunler[][2] | Contiene gli orari dei pasti come coppie ora-minuto; aggiungendo righe puoi aumentare il numero di pasti. |
| mamaVer(adet) | Fa suonare il buzzer e apre e chiude lo sportello per 400 ms tante volte quante sono le porzioni. |
| anahtar / sonBesleme | Garantisce che il pasto venga dato una sola volta anche se il ciclo gira centinaia di volte nello stesso minuto. |
| rtc.isrunning() | Se l'RTC non è mai stato impostato o la pila è scarica, imposta l'ora su quella di compilazione. |
| oncekiBesle / oncekiPors | Rileva l'istante della pressione (fronte di discesa), non la pressione prolungata. |
| ekranYaz() | Aggiorna l'LCD una volta al secondo; riscriverlo a ogni ciclo causa sfarfallio e lentezza. |
La riga più importante del codice è la chiave di erogazione. La funzione loop di Arduino gira decine di volte al secondo; alle 08:00 la condizione risulta vera molte volte durante tutto quel minuto. Con un semplice controllo di uguaglianza la macchina svuoterebbe l'intero serbatoio in quel minuto. Per questo trasformiamo giorno, ora e minuto in un unico numero: giorno × 1440 + ora × 60 + minuto. Se coincide con quello dell'ultima erogazione, il pasto è già stato dato. Considerare anche il giorno fa sì che, pur con un solo pasto in elenco, il giorno dopo alla stessa ora l'erogazione avvenga di nuovo.
Calibrazione della porzione: quanti grammi cadono?
In un serbatoio con sportello a servo la quantità che cade dipende dal tempo di apertura, dal diametro della bocca di uscita e dalla dimensione delle crocchette. Per questo la porzione va misurata, non calcolata. Metti una ciotola vuota su una bilancia da cucina, premi il pulsante di erogazione 10 volte con porzione 1 e dividi il peso totale per 10: è la media in grammi di una singola apertura. Ad esempio, se in 10 aperture cadono 120 g, un'apertura vale circa 12 g. Se per il tuo gatto servono 60 g al giorno in tre pasti, servono 20 g a pasto: significa impostare la porzione a 2 (circa 24 g) oppure ridurre un po' i 400 ms di apertura. Stabilisci la quantità giornaliera in base alla tabella sulla confezione e al consiglio del veterinario.
Versione ESP32: orari dal web e notifica Telegram
L'ESP32 porta due grandi vantaggi. Il primo: prende l'ora da internet (NTP), quindi non serve il modulo RTC e l'ora non deriva. Il secondo: può far girare un proprio server web, così puoi cambiare orari dei pasti e porzione dal browser del telefono collegato alla stessa rete Wi-Fi. Dopo ogni erogazione arriva su Telegram il messaggio "Cibo erogato", e anche quando sei fuori casa sai che il tuo animale ha mangiato. Per compilare il codice installa dal Gestore Librerie UniversalTelegramBot e la libreria ArduinoJson che usa. Il token del bot lo ottieni da BotFather su Telegram, mentre il chat ID lo ricavi dopo aver scritto un messaggio al tuo bot; i dettagli sono nell'articolo Bot 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}In questo codice non usiamo una libreria dedicata per il servo: con l'unità PWM hardware LEDC dell'ESP32 generiamo un segnale a 50 Hz e 14 bit di risoluzione. Un impulso di 500–2400 microsecondi corrisponde a 0–180 gradi. Poiché nella versione 3.x del core Arduino per ESP32 le funzioni LEDC sono cambiate, le due versioni sono separate con ESP_ARDUINO_VERSION_MAJOR; il codice compila sia con la 2.x sia con la 3.x. Orari e porzione vengono scritti nella memoria flash con Preferences, quindi non si perdono nemmeno se manca la corrente. Apri nel browser l'indirizzo IP dell'ESP32 (compare nel Monitor Seriale), scegli gli orari e premi Salva. Il fuso orario è impostato su UTC+3 (Turchia); se sei in un altro paese, cambia la stringa nella riga configTzTime. Per i dettagli su NTP leggi l'articolo Orologio NTP con ESP32.
Distributore di cibo con Raspberry Pi Pico e MicroPython
Anche il Pico ha un'unità orologio interna, ma si azzera quando manca la corrente: per questo un RTC con batteria è indispensabile. Dato che il Pico funziona a 3,3 V, usa il DS3231 al posto del DS1307: ha lo stesso indirizzo 0x68 e gli stessi registri dell'ora e, grazie al cristallo compensato in temperatura, deriva di circa un solo minuto all'anno. Il codice seguente non richiede librerie aggiuntive: legge l'RTC direttamente via I2C e pilota il servo con PWM a 50 Hz. Per impostare l'ora la prima volta, togli il commento dalla riga set_time, esegui il codice una volta e rimetti il commento.
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 debounceConsigli per costruire il modello e la struttura
- Serbatoio: una bottiglia PET da 1,5 litri o un contenitore di plastica con coperchio vanno bene. Il coperchio protegge il cibo dall'umidità e dalle zampe curiose; per le parti a contatto con il cibo usa plastica alimentare.
- Inclinazione del fondo: il fondo del serbatoio deve avere un'inclinazione di almeno 45 gradi. Con fondi più piatti il cibo resta negli angoli e gli ultimi pasti risultano scarsi.
- Bocca di uscita: le crocchette misurano di solito 8–15 mm; fai la bocca di 25–35 mm. Una bocca troppo stretta causa blocchi, una troppo larga fa schiacciare le crocchette quando lo sportello si chiude.
- Sportello: usa una piastra di PVC espanso, cartone pluma o stampata in 3D e fissala al braccio del servo con una vite M2. La colla da sola col tempo si allenta.
- Base solida: gatti e cani spingono la macchina e cercano di ribaltarla per arrivare al cibo. Fai la base larga, aggiungi un peso sotto o fissa la struttura al muro.
- Sicurezza dei cavi: rivesti il cavo dell'alimentatore con una guaina a spirale e metti l'elettronica in una scatola chiusa; un cavo rosicchiato è pericoloso per l'animale e per il dispositivo.
- Circuito definitivo: la breadboard può allentarsi con le vibrazioni. Salda il circuito funzionante su una basetta forata.
Idee per migliorare il distributore
- Ciotola con pesatura: misura il peso della ciotola con HX711 e cella di carico; se è ancora piena non erogare una nuova porzione e dosa il cibo con precisione in grammi.
- Avviso serbatoio vuoto: il sensore di livello senza contatto XKC-Y25 si incolla all'esterno del serbatoio e ti avvisa su Telegram quando il cibo sta finendo.
- Notifica con foto: con ESP32-CAM invii sul telefono a ogni pasto una foto del tuo animale mentre mangia.
- Ciotola dell'acqua automatica: con una mini pompa per acqua e un sensore di livello riempi da sola anche la ciotola dell'acqua.
- Richiamo sonoro: con DFPlayer Mini riproduci all'ora del pasto un richiamo registrato con la tua voce.
- Salvare le impostazioni: nella versione Arduino scrivi la porzione nella EEPROM così, dopo un'interruzione di corrente, non torna al valore predefinito.
Errori comuni e come risolverli
| Problema | Causa probabile | Soluzione |
|---|---|---|
| Arduino si riavvia quando il servo si muove | Il servo è alimentato dal pin 5V della scheda | Usa un alimentatore esterno 5 V 2 A e unisci i GND |
| All'ora del pasto il serbatoio si svuota del tutto | L'erogazione si ripete più volte nello stesso minuto | Mantieni il controllo anahtar / sonBesleme nel codice |
| A ogni accensione l'ora torna a quella di compilazione | Pila RTC mancante o scarica | Sostituisci la CR2032 e controlla i contatti del portapila |
| L'LCD non mostra testo, solo rettangoli | Contrasto da regolare o indirizzo I2C sbagliato | Gira il potenziometro sul retro, prova l'indirizzo 0x3F |
| Le crocchette si bloccano all'uscita | Bocca stretta o poca inclinazione del fondo | Allarga la bocca, aumenta l'inclinazione, aggiungi lo scuotimento allo sportello |
| Il servo ronza e vibra da chiuso | Lo sportello non si appoggia bene e il servo corregge di continuo | Cambia di qualche grado l'angolo KAPALI o usa kapak.detach() dopo il movimento |
| L'ESP32 non eroga mai | NTP non ancora sincronizzato o Wi-Fi assente | Controlla la connessione dal Monitor Seriale; il codice aspetta l'arrivo dell'ora |
Il distributore di cibo automatico riunisce in un unico progetto reale servo, RTC, pulsanti e Wi-Fi, quindi è ottimo sia come progetto scolastico sia come dispositivo da usare davvero in casa. Per approfondire servo e RTC leggi gli articoli sul servo motore e sul modulo orologio RTC. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, i progetti su servo, orologio con RTC, NTP con ESP32 e allarmi con notifica Telegram, così puoi provare separatamente ogni parte di questo distributore.
Domande frequenti
Quale servo motore usare per un distributore di cibo automatico?
Per uno sportello leggero basta l'SG90, la scelta più economica. Se lo sportello è pesante, il serbatoio è grande o il cibo preme sullo sportello, scegli l'MG90S con ingranaggi metallici o l'MG996R. Per coclee o tamburi rotanti sono più adatti il servo a rotazione continua FS90R o il motore passo-passo 28BYJ-48.
Se manca la corrente, il distributore perde l'ora?
Grazie alla pila CR2032 del modulo RTC l'ora si conserva e, quando torna la corrente, la macchina riprende a erogare all'ora giusta. Il pasto che cade durante l'interruzione, però, viene saltato. La versione ESP32 invece riprende l'ora da internet via NTP quando si ricollega al Wi-Fi.
Quanti pasti al giorno può dare un distributore con Arduino?
Aggiungendo righe all'array ogunler nel codice puoi definire tutti i pasti che vuoi. La memoria di Arduino Uno basta e avanza per decine di pasti. Il limite pratico sono il fabbisogno giornaliero del tuo animale e lo schema di pasti consigliato dal veterinario.
Il distributore può funzionare con un power bank o con le batterie?
Per periodi brevi sì; un power bank con uscita 5 V è la scelta più pratica. Arduino Uno e LCD insieme assorbono circa 60–70 mA, quindi un power bank da 10000 mAh dura grosso modo 3–4 giorni. Alcuni power bank si spengono con correnti basse, perciò per un uso prolungato è più affidabile un alimentatore 5 V.
Posso controllare il distributore ESP32 da fuori casa?
Il pannello web dell'esempio funziona solo sulla stessa rete Wi-Fi. Per il controllo da remoto puoi aggiungere al bot Telegram l'ascolto di comandi come /besle oppure usare MQTT o un servizio cloud come Blynk. Aprire il port forwarding sul router è sconsigliato per motivi di sicurezza.
Il distributore automatico si può usare per il cibo umido?
Il serbatoio con sportello a servo è solo per crocchette: il cibo umido non scivola, si accumula sullo sportello e si rovina in fretta. Per l'umido servono progetti in cui ogni pasto aspetta in uno scomparto separato, il cui coperchio si apre con il servo all'ora stabilita, meglio se raffreddati con un panetto di ghiaccio.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Accendere e spegnere un LED con un pulsante
Premi il pulsante una volta e la luce si accende, premilo di nuovo e si spegne, proprio come l'interruttore della tua stanza.

Utilizzo del servomotore
Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

Configurazione del modulo orologio RTC DS1302
Metti in funzione un piccolo modulo orologio che non dimentica l'ora nemmeno quando l'Arduino è spento.

DS1302 Orologio RTC con display LCD
Un piccolo orologio da scrivania che non dimentica l'ora nemmeno se manca la corrente.

Orologio digitale con ESP32 e RTC DS1307 (I2C + LCD)
In questo progetto, utilizziamo il modulo orologio in tempo reale (RTC) DS1307 per visualizzare l'ora e la data su un display LCD 16x2 I2C. Il DS1307 è un RTC con batteria di supporto che mantiene l'ora anche se l'ESP32 si spegne. Entrambi i moduli condividono la stessa linea I2C (SDA/SCL), permettendoci di imparare a controllare più dispositivi utilizzando solo due cavi di segnale. Cosi imparerai il protocollo I2C e il funzionamento dei moduli RTC nella pratica.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

