Guide · 9 min di lettura

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.

Servo motore SG90 per lo sportello del distributore di cibo automatico
Micro servo SG90: apre e chiude lo sportello del serbatoio tra 0° e 80° e rilascia la porzione.

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.

ComponenteFunzioneNota
Arduino Uno (o Nano)Scheda di controllo principaleCon il Nano la struttura è più piccola
Servo motore SG90Apre e chiude lo sportelloPer sportelli pesanti usa MG90S o MG996R
Modulo RTC DS1307Tiene ora e dataCon pila CR2032 l'ora resta salva senza corrente; richiede 5 V
2 pulsantiErogazione manuale e scelta porzionePull-up interno, nessuna resistenza necessaria
Buzzer attivoSegnale del pastoL'animale con il tempo si abitua al suono
LCD 16x2 I2CMostra ora e porzioneIndirizzo di solito 0x27 o 0x3F
Alimentatore 5 V 2 AAlimenta servo e schedaNon alimentare il servo dall'USB
Serbatoio, imbuto, strutturaContengono e guidano il ciboBottiglia 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.

MeccanismoMotoreCostanza della porzioneDifficoltà
Serbatoio con sportello a servoSG90 / MG90SMedia, dipende dalla dimensione delle crocchetteFacile
Coclea (vite senza fine)Servo a rotazione continua FS90R o motore passo-passo 28BYJ-48AltaMedia, serve la stampa 3D
Tamburo rotante (ruota a scomparti)Motore passo-passo 28BYJ-48Alta, pari al volume dello scompartoMedia
Cursore scorrevoleServo MG996RMediaFacile–media
Modulo orologio RTC DS1307
Modulo RTC DS1307: fornisce ora e data via I2C e, grazie alla pila CR2032 sul retro, non perde l'ora quando manca la corrente.

Schema dei collegamenti: pin di Arduino Uno, ESP32 e Pico

Componente / pinArduino UnoESP32Raspberry Pi Pico
Segnale servo (arancione)D9GPIO 18GP15
VCC servo (rosso)5 V esterni5 V esterni5 V esterni
GND servo (marrone)GND (in comune)GND (in comune)GND (in comune)
Pulsante erogazioneD2 – GNDGPIO 25 – GNDGP14 – GND
Pulsante porzioneD3 – GNDGPIO 26 – GNDGP13 – GND
Buzzer attivo (+)D8GPIO 27GP16
SDA RTC / LCDA4Non serve (NTP)GP4 (DS3231)
SCL RTC / LCDA5Non serve (NTP)GP5 (DS3231)
VCC RTC5V (DS1307)—3V3 (DS3231)
Non alimentare il servo dal pin 5V di Arduino. Quando lo sportello fa sforzo, l'SG90 può assorbire per un istante centinaia di milliampere: la tensione della scheda cala, Arduino si riavvia o l'RTC legge valori senza senso. Alimenta il servo con un alimentatore 5 V separato e collega sempre il GND dell'alimentatore al GND di Arduino. Inoltre il DS1307 richiede almeno 4,5 V; con schede a 3,3 V come ESP32 e Pico usa il DS3231, che funziona anche a 3,3 V.

Montaggio passo dopo passo

  1. Nel Gestore Librerie dell'Arduino IDE installa RTClib (Adafruit) e LiquidCrystal I2C (Frank de Brabander); la libreria Servo è già inclusa nell'IDE.
  2. Collega modulo RTC e LCD allo stesso bus I2C (A4 = SDA, A5 = SCL); non vanno in conflitto perché hanno indirizzi diversi (0x68 e 0x27).
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. Metti una ciotola sotto il serbatoio, premi il pulsante di erogazione per qualche prova e pesa il cibo caduto per calibrare la porzione.
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}

Come funziona il codice?

SezioneCosa 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 / sonBeslemeGarantisce 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 / oncekiPorsRileva 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.

Invece di tenere lo sportello aperto a lungo in una volta sola, aprirlo più volte e per poco rende la porzione più costante e riduce il rischio che le crocchette formino un ponte e si blocchino all'uscita. Se si bloccano, aiuta anche aggiungere un piccolo movimento di scuotimento avanti e indietro di 50 ms prima di chiudere lo sportello.

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.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4#include <WiFiClientSecure.h>
5#include <UniversalTelegramBot.h>
6#include <time.h>
7
8const char* WIFI_SSID = "WIFI_ADI";        // Wi-Fi adın / your Wi-Fi name
9const char* WIFI_PASS = "WIFI_SIFRESI";    // Wi-Fi şifren / your Wi-Fi password
10#define BOT_TOKEN "123456789:ABCdefGhIJKlmnoPQRstuVWxyz"   // BotFather token'ı / BotFather token
11#define CHAT_ID   "123456789"                              // senin chat ID'n / your chat ID
12
13const int SERVO_PIN   = 18;
14const int SERVO_CH    = 0;                 // yalnız core 2.x için / core 2.x only
15const int FEED_BTN    = 25;
16const int PORTION_BTN = 26;
17const int BUZZER_PIN  = 27;
18const int KAPALI = 0;
19const int ACIK   = 80;
20
21WebServer server(80);
22Preferences prefs;
23WiFiClientSecure secured;
24UniversalTelegramBot bot(BOT_TOKEN, secured);
25
26uint8_t saatH[3] = {8, 13, 19};            // öğün saatleri / feeding hours
27uint8_t saatM[3] = {0, 0, 30};             // öğün dakikaları / feeding minutes
28uint8_t porsiyon = 2;
29long sonBesleme = -1;
30
31void servoYaz(int aci) {
32  uint32_t us = 500 + (uint32_t)aci * 1900 / 180;   // 500-2400 us darbe / pulse
33  uint32_t duty = us * 16383UL / 20000UL;           // 14 bit, 20 ms periyot / period
34#if ESP_ARDUINO_VERSION_MAJOR >= 3
35  ledcWrite(SERVO_PIN, duty);
36#else
37  ledcWrite(SERVO_CH, duty);
38#endif
39}
40
41void bip(int ms) {
42  digitalWrite(BUZZER_PIN, HIGH);
43  delay(ms);
44  digitalWrite(BUZZER_PIN, LOW);
45}
46
47void ayarlariOku() {
48  prefs.begin("mama", false);
49  char k[4];
50  for (int i = 0; i < 3; i++) {
51    snprintf(k, sizeof(k), "h%d", i);
52    saatH[i] = prefs.getUChar(k, saatH[i]);
53    snprintf(k, sizeof(k), "m%d", i);
54    saatM[i] = prefs.getUChar(k, saatM[i]);
55  }
56  porsiyon = prefs.getUChar("p", porsiyon);
57  prefs.end();
58}
59
60void ayarlariYaz() {                        // flash'a kaydet / save to flash
61  prefs.begin("mama", false);
62  char k[4];
63  for (int i = 0; i < 3; i++) {
64    snprintf(k, sizeof(k), "h%d", i);
65    prefs.putUChar(k, saatH[i]);
66    snprintf(k, sizeof(k), "m%d", i);
67    prefs.putUChar(k, saatM[i]);
68  }
69  prefs.putUChar("p", porsiyon);
70  prefs.end();
71}
72
73void mamaVer(uint8_t adet, const char* neden) {
74  bip(300);
75  for (uint8_t i = 0; i < adet; i++) {
76    servoYaz(ACIK);
77    delay(400);
78    servoYaz(KAPALI);
79    delay(500);
80  }
81  if (WiFi.status() == WL_CONNECTED) {      // Telegram bildirimi / Telegram notification
82    String msg = "Mama verildi / Food served: ";
83    msg += adet;
84    msg += " porsiyon (";
85    msg += neden;
86    msg += ")";
87    bot.sendMessage(CHAT_ID, msg, "");
88  }
89}
90
91void sayfaGonder() {                        // ayar sayfası / settings page
92  String h = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
93  h += "<meta name='viewport' content='width=device-width'><title>Mama</title></head><body>";
94  h += "<h2>Mama Makinesi</h2><form action='/kaydet'>";
95  for (int i = 0; i < 3; i++) {
96    char satir[100];
97    snprintf(satir, sizeof(satir), "Öğün %d: <input name='t%d' type='time' value='%02d:%02d'><br>",
98             i + 1, i, saatH[i], saatM[i]);
99    h += satir;
100  }
101  h += "Porsiyon (1-5): <input name='p' type='number' min='1' max='5' value='";
102  h += porsiyon;
103  h += "'><br><button>Kaydet</button></form>";
104  h += "<form action='/besle'><button>Şimdi besle</button></form></body></html>";
105  server.send(200, "text/html", h);
106}
107
108void kaydet() {
109  for (int i = 0; i < 3; i++) {
110    String ad = String("t") + i;
111    if (server.hasArg(ad)) {
112      String v = server.arg(ad);            // "HH:MM" biçimi / format
113      if (v.length() >= 5) {
114        long hh = v.substring(0, 2).toInt();
115        long mm = v.substring(3, 5).toInt();
116        if (hh >= 0 && hh < 24 && mm >= 0 && mm < 60) {
117          saatH[i] = hh;
118          saatM[i] = mm;
119        }
120      }
121    }
122  }
123  if (server.hasArg("p")) {
124    long p = server.arg("p").toInt();
125    if (p < 1) p = 1;
126    if (p > 5) p = 5;
127    porsiyon = p;
128  }
129  ayarlariYaz();
130  server.sendHeader("Location", "/");
131  server.send(303);
132}
133
134void setup() {
135  Serial.begin(115200);
136  pinMode(FEED_BTN, INPUT_PULLUP);
137  pinMode(PORTION_BTN, INPUT_PULLUP);
138  pinMode(BUZZER_PIN, OUTPUT);
139#if ESP_ARDUINO_VERSION_MAJOR >= 3
140  ledcAttach(SERVO_PIN, 50, 14);            // 50 Hz, 14 bit (core 3.x)
141#else
142  ledcSetup(SERVO_CH, 50, 14);              // 50 Hz, 14 bit (core 2.x)
143  ledcAttachPin(SERVO_PIN, SERVO_CH);
144#endif
145  servoYaz(KAPALI);
146  ayarlariOku();
147
148  WiFi.mode(WIFI_STA);
149  WiFi.begin(WIFI_SSID, WIFI_PASS);
150  while (WiFi.status() != WL_CONNECTED) {
151    delay(500);
152    Serial.print(".");
153  }
154  Serial.println();
155  Serial.println(WiFi.localIP());           // tarayıcıda bu adresi aç / open this address in the browser
156
157  configTzTime("<+03>-3", "pool.ntp.org"); // Türkiye UTC+3 / Turkey UTC+3
158  secured.setCACert(TELEGRAM_CERTIFICATE_ROOT);
159
160  server.on("/", sayfaGonder);
161  server.on("/kaydet", kaydet);
162  server.on("/besle", []() {
163    mamaVer(porsiyon, "web");
164    server.sendHeader("Location", "/");
165    server.send(303);
166  });
167  server.begin();
168  bot.sendMessage(CHAT_ID, "Mama makinesi acildi / Feeder online", "");
169}
170
171void loop() {
172  server.handleClient();
173
174  struct tm t;
175  if (getLocalTime(&t, 10)) {               // saat senkronize ise / if time is synced
176    for (int i = 0; i < 3; i++) {
177      if (t.tm_hour == saatH[i] && t.tm_min == saatM[i]) {
178        long anahtar = (long)t.tm_yday * 1440L + t.tm_hour * 60 + t.tm_min;
179        if (anahtar != sonBesleme) {
180          sonBesleme = anahtar;
181          mamaVer(porsiyon, "zamanli / scheduled");
182        }
183      }
184    }
185  }
186
187  static bool oncekiBesle = HIGH, oncekiPors = HIGH;
188  bool b1 = digitalRead(FEED_BTN);
189  if (b1 == LOW && oncekiBesle == HIGH) mamaVer(porsiyon, "buton / button");
190  oncekiBesle = b1;
191
192  bool b2 = digitalRead(PORTION_BTN);
193  if (b2 == LOW && oncekiPors == HIGH) {
194    porsiyon = porsiyon % 5 + 1;
195    ayarlariYaz();
196    bip(80);
197  }
198  oncekiPors = b2;
199  delay(20);
200}

In 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.

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

Consigli 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

ProblemaCausa probabileSoluzione
Arduino si riavvia quando il servo si muoveIl servo è alimentato dal pin 5V della schedaUsa un alimentatore esterno 5 V 2 A e unisci i GND
All'ora del pasto il serbatoio si svuota del tuttoL'erogazione si ripete più volte nello stesso minutoMantieni il controllo anahtar / sonBesleme nel codice
A ogni accensione l'ora torna a quella di compilazionePila RTC mancante o scaricaSostituisci la CR2032 e controlla i contatti del portapila
L'LCD non mostra testo, solo rettangoliContrasto da regolare o indirizzo I2C sbagliatoGira il potenziometro sul retro, prova l'indirizzo 0x3F
Le crocchette si bloccano all'uscitaBocca stretta o poca inclinazione del fondoAllarga la bocca, aumenta l'inclinazione, aggiungi lo scuotimento allo sportello
Il servo ronza e vibra da chiusoLo sportello non si appoggia bene e il servo corregge di continuoCambia di qualche grado l'angolo KAPALI o usa kapak.detach() dopo il movimento
L'ESP32 non eroga maiNTP non ancora sincronizzato o Wi-Fi assenteControlla la connessione dal Monitor Seriale; il codice aspetta l'arrivo dell'ora
Prima di usare davvero la macchina, imposta gli orari dei pasti a distanza di un minuto, testala per un'ora e pesa ogni porzione. Nei primi giorni affianca il distributore ai pasti dati a mano; di solito l'animale impiega qualche giorno ad associare il suono del buzzer al cibo e così si abitua più facilmente alla nuova routine.

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.

Vedi tutti i progetti
Accendere e spegnere un LED con un pulsante
AR-10Principiante

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.

4.7(103)
177
Utilizzo del servomotore
AR-35Principiante
Premium

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.

4.7(48)
67
Configurazione del modulo orologio RTC DS1302
AR-45Principiante

Configurazione del modulo orologio RTC DS1302

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

4.5(23)
31
DS1302 Orologio RTC con display LCD
AR-46Intermedio
Premium

DS1302 Orologio RTC con display LCD

Un piccolo orologio da scrivania che non dimentica l'ora nemmeno se manca la corrente.

4.7(41)
51
Orologio digitale con ESP32 e RTC DS1307 (I2C + LCD)
ES-18Intermedio
Premium

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.

4.6(26)
40
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

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.

4.5(13)
22
Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzato
Premium

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.

9