Guides · 10 min de lecture

Distributeur de croquettes automatique Arduino : horloge RTC

Fabrique un distributeur de croquettes automatique avec Arduino : trappe à servo, horaires RTC DS1307, portions réglables, panneau web ESP32 et Telegram.

Un distributeur de croquettes automatique est un petit appareil électronique qui sert à ton chat ou à ton chien la quantité de croquettes que tu as choisie, aux heures que tu as choisies. Pour fabriquer un distributeur de croquettes automatique avec Arduino, il te faut une trémie, un servomoteur qui ouvre et ferme la sortie, un module RTC (horloge temps réel) qui n'oublie jamais l'heure et deux boutons pour régler la portion. Le coût total ne représente qu'une petite fraction d'un distributeur du commerce, et c'est toi qui décides de l'heure et de la quantité.

Dans ce guide, on construit d'abord la version de base avec Arduino Uno : trois repas par jour avec un RTC DS1307, une trémie à trappe SG90, un bouton pour servir tout de suite, un autre pour choisir la portion de 1 à 5, et l'heure affichée sur un LCD I2C. Ensuite, tu verras comment, avec l'ESP32, modifier les horaires depuis le navigateur de ton téléphone et recevoir une notification Telegram à chaque repas, puis comment écrire la même logique pour le Raspberry Pi Pico en MicroPython. À la fin, des conseils de fabrication t'aident à éviter les blocages de croquettes, à empêcher l'animal de renverser la machine et à garder un boîtier solide.

Trappe de distributeur de croquettes automatique avec servomoteur SG90
Micro-servo SG90 : il ouvre et ferme la trappe de la trémie entre 0° et 80° pour laisser tomber la portion.

Qu'est-ce qu'un distributeur de croquettes automatique et comment fonctionne-t-il ?

Le principe est très simple : les croquettes attendent dans une trémie en haut et glissent par gravité vers l'étroite sortie en bas. Une trappe reliée à un servomoteur ferme cette sortie. À chaque tour de boucle, l'Arduino lit l'heure sur le module RTC ; quand elle correspond à l'un des horaires de la liste, le servo ouvre brièvement la trappe, les croquettes tombent dans la gamelle, puis la trappe se referme. Le nombre d'ouvertures détermine la portion. Grâce à la pile bouton du module RTC, l'heure n'est pas perdue en cas de coupure de courant : la machine reprend le service à la bonne heure dès qu'elle est réalimentée. Les boutons servent au repas manuel et au réglage de la portion, et le buzzer émet un court signal avant chaque repas.

ComposantRôleRemarque
Arduino Uno (ou Nano)Carte de contrôle principaleAvec une Nano, le boîtier est plus petit
Servomoteur SG90Ouvre et ferme la trappeMG90S ou MG996R pour une trappe lourde
Module RTC DS1307Garde l'heure et la datePile CR2032 pour conserver l'heure ; alimentation 5 V
2 boutons poussoirsRepas manuel et choix de la portionPull-up interne utilisé, pas de résistance
Buzzer actifSignal de repasL'animal finit par s'habituer au son
LCD 16x2 I2CAffiche l'heure et la portionAdresse généralement 0x27 ou 0x3F
Adaptateur 5 V 2 AAlimente le servo et la carteN'alimente pas le servo par l'USB
Trémie, entonnoir, boîtierStocke et guide les croquettesBouteille en plastique, boîte de rangement, PVC expansé ou impression 3D

Choix du mécanisme : trappe, vis sans fin ou tambour rotatif

Le mécanisme qui libère les croquettes est le cœur du distributeur, et ce choix influence à la fois le code et le boîtier. Pour débuter, le plus simple est la trémie à trappe sur servo : une trappe vissée au bras du servo ferme la sortie, et les croquettes s'écoulent quand elle s'ouvre. Si tu veux une portion plus précise, tu peux utiliser une vis sans fin ou un tambour rotatif à compartiments ; ces mécanismes transportent les croquettes au volume, donc la quantité est presque identique à chaque tour, mais ils demandent une impression 3D ou un travail mécanique plus soigné.

MécanismeMoteurRégularité de la portionDifficulté
Trémie à trappe sur servoSG90 / MG90SMoyenne, varie selon la taille des croquettesFacile
Vis sans finServo à rotation continue FS90R ou moteur pas à pas 28BYJ-48ÉlevéeMoyenne, impression 3D nécessaire
Tambour rotatif (roue à compartiments)Moteur pas à pas 28BYJ-48Élevée, selon le volume du compartimentMoyenne
Tiroir coulissantServo MG996RMoyenneFacile à moyenne
Module horloge RTC DS1307
Module RTC DS1307 : il fournit l'heure et la date en I2C, et grâce à sa pile CR2032 il garde l'heure même sans courant.

Schéma de câblage : broches Arduino Uno, ESP32 et Pico

Pièce / brocheArduino UnoESP32Raspberry Pi Pico
Signal servo (orange)D9GPIO 18GP15
VCC servo (rouge)5 V externe5 V externe5 V externe
GND servo (marron)GND (commun)GND (commun)GND (commun)
Bouton de repasD2 – GNDGPIO 25 – GNDGP14 – GND
Bouton de portionD3 – GNDGPIO 26 – GNDGP13 – GND
Buzzer actif (+)D8GPIO 27GP16
SDA RTC / LCDA4Inutile (NTP)GP4 (DS3231)
SCL RTC / LCDA5Inutile (NTP)GP5 (DS3231)
VCC RTC5V (DS1307)—3V3 (DS3231)
N'alimente pas le servo par la broche 5V de l'Arduino. Quand la trappe force, un SG90 peut appeler d'un coup plusieurs centaines de milliampères ; la tension de la carte chute, l'Arduino redémarre ou le RTC renvoie des valeurs absurdes. Alimente le servo avec un adaptateur 5 V séparé et relie impérativement sa masse au GND de l'Arduino. De plus, le DS1307 demande au moins 4,5 V ; sur les cartes 3,3 V comme l'ESP32 et le Pico, utilise plutôt un DS3231, qui fonctionne aussi en 3,3 V.

Montage pas à pas

  1. Dans l'IDE Arduino, installe depuis le Gestionnaire de bibliothèques RTClib (Adafruit) et LiquidCrystal I2C (Frank de Brabander) ; la bibliothèque Servo est déjà fournie avec l'IDE.
  2. Branche le module RTC et le LCD sur le même bus I2C (A4 = SDA, A5 = SCL) ; ils n'entrent pas en conflit car leurs adresses sont différentes (0x68 et 0x27).
  3. Relie le fil de signal du servo à D9 et ses fils rouge et marron à l'adaptateur 5 V externe ; connecte la masse de l'adaptateur au GND de l'Arduino.
  4. Branche une patte de chaque bouton sur D2 et D3 et l'autre sur GND. Comme le code utilise INPUT_PULLUP, aucune résistance externe n'est nécessaire.
  5. Insère la pile CR2032 dans le RTC et téléverse le code. Si le RTC n'a jamais été réglé, l'heure est réglée sur celle de l'ordinateur au moment de la compilation.
  6. Avant de fixer le bras du servo, laisse le code amener le servo à 0°, puis visse le bras avec la trappe en position fermée. Ainsi, les angles ACIK et KAPALI s'adaptent parfaitement à ton mécanisme.
  7. Place une gamelle sous la trémie, fais quelques essais avec le bouton de repas et calibre la portion en pesant les croquettes tombées.
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}

Comment fonctionne le code ?

PartieCe qu'elle fait
ogunler[][2]Stocke les horaires de repas sous forme de couples heure-minute ; ajoute une ligne pour augmenter le nombre de repas.
mamaVer(adet)Fait sonner le buzzer, puis ouvre et ferme la trappe 400 ms autant de fois que la portion.
anahtar / sonBeslemeGarantit que le repas n'est servi qu'une seule fois, même si la boucle tourne des centaines de fois dans la même minute.
rtc.isrunning()Règle l'heure sur celle de la compilation si le RTC n'a jamais été réglé ou si sa pile est épuisée.
oncekiBesle / oncekiPorsDétecte l'instant de l'appui (front descendant) et non le maintien du bouton.
ekranYaz()Met à jour le LCD une fois par seconde ; écrire à chaque tour de boucle provoque du scintillement et des ralentissements.

La ligne la plus critique du code est la clé de service. La fonction loop de l'Arduino tourne des dizaines de fois par seconde ; à 08:00, la condition est vraie de nombreuses fois pendant toute la minute. Avec un simple test d'égalité, la machine viderait toute la trémie en une minute. On convertit donc le jour, l'heure et la minute en un seul nombre : jour × 1440 + heure × 60 + minute. Si ce nombre est identique à celui du dernier service, le repas a déjà été donné. Prendre aussi le jour en compte permet de servir de nouveau à la même heure le lendemain, même s'il n'y a qu'un seul repas dans la liste.

Calibrage de la portion : combien de grammes tombent ?

Avec une trémie à trappe, la quantité qui tombe dépend du temps d'ouverture, du diamètre de la sortie et de la taille des croquettes. Il faut donc mesurer la portion plutôt que la calculer. Pose une boîte vide sur une balance de cuisine, appuie 10 fois sur le bouton de repas avec la portion à 1, puis divise le poids total par 10 : c'est la masse moyenne d'une ouverture. Par exemple, si 10 ouvertures donnent 120 g, une ouverture vaut environ 12 g. Si ton chat a besoin de 60 g par jour en trois repas, il faut 20 g par repas ; cela revient à régler la portion sur 2 (environ 24 g) ou à raccourcir un peu le temps d'ouverture de 400 ms. Détermine la quantité quotidienne d'après le tableau du paquet de croquettes et les conseils de ton vétérinaire.

Plutôt que d'ouvrir la trappe longtemps d'un coup, l'ouvrir brièvement plusieurs fois rend la portion plus régulière et limite la formation d'un pont de croquettes qui bloque la sortie. Si tu as des blocages, ajoute aussi un petit mouvement de va-et-vient de 50 ms avant de refermer la trappe.

Version ESP32 : horaires par le web et notification Telegram

L'ESP32 apporte deux grands avantages. D'abord, il récupère l'heure sur Internet (NTP), donc plus besoin de module RTC et l'heure ne dérive pas. Ensuite, il peut faire tourner son propre serveur web : tu changes les horaires et la portion depuis le navigateur de ton téléphone, sur le même réseau Wi-Fi. Après chaque service, un message « Mama verildi » arrive sur Telegram ; même loin de chez toi, tu sais que ton animal a mangé. Pour compiler le code, installe depuis le Gestionnaire de bibliothèques UniversalTelegramBot et la bibliothèque ArduinoJson qu'elle utilise. Tu obtiens le token du bot auprès de BotFather sur Telegram, et ton chat ID après avoir envoyé un message à ton bot ; les détails sont dans l'article Bot Telegram avec 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}

Dans ce code, nous n'avons pas utilisé de bibliothèque pour le servo ; on génère le signal à 50 Hz et en 14 bits avec l'unité PWM matérielle LEDC de l'ESP32. Une largeur d'impulsion de 500 à 2400 microsecondes correspond à 0–180 degrés. Comme les fonctions LEDC ont changé dans la version 3.x du cœur Arduino pour ESP32, les deux versions sont séparées par ESP_ARDUINO_VERSION_MAJOR ; le code compile avec la 2.x comme avec la 3.x. Les horaires et la portion sont écrits en mémoire flash avec Preferences, donc ils ne sont pas perdus en cas de coupure de courant. Ouvre l'adresse IP de l'ESP32 dans le navigateur (elle s'affiche dans le moniteur série), choisis les heures et appuie sur Enregistrer. Le fuseau horaire est réglé sur UTC+3 (Turquie) ; si tu es dans un autre pays, modifie la chaîne de la ligne configTzTime. Pour les détails du NTP, consulte l'article Horloge NTP avec ESP32.

Distributeur de croquettes avec Raspberry Pi Pico et MicroPython

Le Pico possède aussi une horloge interne, mais elle est remise à zéro à chaque coupure de courant ; un RTC sur pile est donc indispensable. Comme le Pico fonctionne en 3,3 V, utilise un DS3231 à la place du DS1307 : il a la même adresse 0x68 et les mêmes registres d'heure, et grâce à son quartz compensé en température, il ne dérive que d'environ une minute par an. Le code suivant n'a besoin d'aucune bibliothèque supplémentaire ; il lit le RTC directement en I2C et pilote le servo en PWM 50 Hz. Pour régler l'heure la première fois, retire le commentaire au début de la ligne set_time, exécute le code une fois, puis remets la ligne en commentaire.

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

Conseils de fabrication du boîtier et de la maquette

  • Trémie : une bouteille en plastique de 1,5 litre ou une boîte de rangement à couvercle fait l'affaire. Avec un couvercle, les croquettes sont protégées de l'humidité et des pattes curieuses ; pour les pièces en contact avec les croquettes, utilise du plastique alimentaire.
  • Inclinaison du fond : le fond de la trémie doit être incliné d'au moins 45 degrés. Avec un fond plus plat, les croquettes restent dans les coins et les derniers repas tombent incomplets.
  • Sortie : les croquettes sèches font généralement 8 à 15 mm ; fais une sortie de 25 à 35 mm. Une ouverture trop étroite provoque des blocages, une trop large écrase les croquettes à la fermeture de la trappe.
  • Trappe : utilise une plaque de PVC expansé, de carton mousse ou imprimée en 3D, fixée au bras du servo avec une vis M2. La colle seule finit par lâcher.
  • Base solide : chats et chiens poussent la machine pour atteindre les croquettes et essaient de la renverser. Choisis une base large, ajoute du poids dessous ou fixe le boîtier au mur.
  • Sécurité des câbles : protège le câble de l'adaptateur avec une gaine spirale et place l'électronique dans un boîtier fermé ; un câble rongé est dangereux pour l'animal comme pour l'appareil.
  • Circuit permanent : une breadboard peut se desserrer avec les vibrations. Soude le circuit qui fonctionne sur une plaque à trous.

Idées pour améliorer le distributeur

  • Gamelle pesée : mesure le poids de la gamelle avec un HX711 et une cellule de charge ; ne sers pas de nouvelle portion si la gamelle est encore pleine, et distribue au gramme près.
  • Alerte trémie vide : un capteur de niveau sans contact XKC-Y25 se colle à l'extérieur de la trémie et te prévient sur Telegram quand il reste peu de croquettes.
  • Notification avec photo : avec une ESP32-CAM, envoie sur ton téléphone une photo de ton animal en train de manger à chaque repas.
  • Fontaine automatique : remplis aussi la gamelle d'eau toute seule avec une mini pompe à eau et un capteur de niveau.
  • Appel sonore : avec un DFPlayer Mini, joue à l'heure du repas un appel enregistré avec ta propre voix.
  • Sauvegarde des réglages : dans la version Arduino, écris la portion dans l'EEPROM pour qu'elle ne revienne pas à la valeur par défaut après une coupure de courant.

Erreurs fréquentes et solutions

ProblèmeCause probableSolution
L'Arduino redémarre quand le servo bougeLe servo est alimenté par la broche 5V de la carteUtilise un adaptateur externe 5 V 2 A et relie les masses
La trémie se vide complètement à l'heure du repasLe service se répète plusieurs fois dans la même minuteGarde le contrôle anahtar / sonBesleme du code
L'heure revient à celle de la compilation à chaque mise sous tensionLa pile du RTC est absente ou épuiséeRemplace la pile CR2032 et vérifie les contacts du support
Le LCD n'affiche que des rectanglesContraste mal réglé ou mauvaise adresse I2CTourne le potentiomètre au dos, essaie l'adresse 0x3F
Les croquettes se bloquent à la sortieOuverture trop étroite ou fond pas assez inclinéÉlargis la sortie, augmente l'inclinaison, ajoute un mouvement de secousse à la trappe
Le servo bourdonne et vibre en position ferméeLa trappe ne se place pas bien, le servo corrige en permanenceChange l'angle KAPALI de quelques degrés ou utilise kapak.detach() après le mouvement
L'ESP32 ne sert jamais de repasLe NTP n'est pas encore synchronisé ou pas de Wi-FiVérifie la connexion dans le moniteur série ; le code attend que l'heure soit disponible
Avant la mise en service réelle, règle les horaires à une minute d'intervalle, teste pendant une heure et pèse chaque portion. Les premiers jours, utilise le distributeur en plus de repas donnés à la main ; il faut généralement quelques jours à l'animal pour associer le son du buzzer aux croquettes, et il s'habitue ainsi plus facilement à la nouvelle routine.

Le distributeur de croquettes automatique réunit servo, RTC, boutons et Wi-Fi dans un seul projet concret ; c'est donc un excellent projet scolaire et un appareil vraiment utile à la maison. Pour les détails du servo et du RTC, consulte les articles servomoteur et module RTC. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets de servo, d'horloge RTC, de NTP avec ESP32 et d'alarme avec notification Telegram, pour tester séparément chaque élément de ce distributeur.

Questions fréquentes

Quel servomoteur choisir pour un distributeur de croquettes automatique ?

Pour une trappe légère, le SG90 suffit et c'est le choix le moins cher. Si la trappe est lourde, si la trémie est grande ou si les croquettes appuient sur la trappe, préfère un MG90S ou un MG996R à pignons métalliques. Pour une vis sans fin ou un tambour rotatif, un servo à rotation continue FS90R ou un moteur pas à pas 28BYJ-48 convient mieux.

Le distributeur oublie-t-il l'heure en cas de coupure de courant ?

Grâce à la pile CR2032 du module RTC, l'heure est conservée et la machine reprend le service à la bonne heure quand le courant revient. En revanche, un repas tombant pendant la coupure est sauté. La version ESP32 récupère l'heure par NTP dès qu'elle se reconnecte au Wi-Fi.

Combien de repas par jour un distributeur Arduino peut-il servir ?

Tu peux définir autant de repas que tu veux en ajoutant des lignes au tableau ogunler du code. La mémoire d'un Arduino Uno est largement suffisante pour des dizaines de repas. La vraie limite, c'est le besoin quotidien de ton animal et le rythme de repas conseillé par ton vétérinaire.

Le distributeur peut-il fonctionner avec une batterie externe ou des piles ?

Pour une courte durée, oui ; une batterie externe avec sortie 5 V est le choix le plus pratique. Un Arduino Uno avec LCD consomme environ 60–70 mA, donc une batterie de 10 000 mAh tient à peu près 3 à 4 jours. Certaines batteries s'éteignent à faible courant ; pour un usage prolongé, un adaptateur 5 V est plus fiable.

Puis-je contrôler le distributeur ESP32 depuis l'extérieur de la maison ?

Le panneau web de l'exemple ne fonctionne que sur le même réseau Wi-Fi. Pour le contrôler à distance, tu peux faire écouter au bot Telegram des commandes comme /besle, ou utiliser un service cloud comme MQTT ou Blynk. Ouvrir une redirection de port sur ta box n'est pas conseillé pour des raisons de sécurité.

Peut-on utiliser ce distributeur pour de la pâtée humide ?

La trémie à trappe sur servo ne convient qu'aux croquettes sèches ; la pâtée humide ne coule pas, s'accumule sur la trappe et se gâte vite. Pour de la pâtée, il faut une conception où chaque repas attend dans un compartiment séparé dont le couvercle est ouvert à l'heure par un servo, de préférence refroidi avec un pack de glace.

Voir tous les projets
Allumer et éteindre une LED avec un bouton
AR-10Débutant

Allumer et éteindre une LED avec un bouton

Un appui et la lumière s'allume, un deuxième et elle s'éteint, exactement comme l'interrupteur de ta chambre.

4.7(103)
177
Utilisation du servomoteur
AR-35Débutant
Premium

Utilisation du servomoteur

Le bras d'un petit servomoteur tourne tour à tour vers trois positions : tout au début, pile au milieu et tout au bout, en attendant deux secondes à chaque arrêt.

4.7(48)
67
Configuration du module horloge RTC DS1302
AR-45Débutant

Configuration du module horloge RTC DS1302

Tu fais fonctionner un petit module horloge qui n'oublie jamais l'heure, même quand l'Arduino est éteint.

4.5(23)
31
Horloge RTC DS1302 avec écran LCD
AR-46Intermédiaire
Premium

Horloge RTC DS1302 avec écran LCD

Une petite horloge de bureau qui n'oublie pas l'heure, même en cas de coupure de courant.

4.7(41)
51
Horloge numérique avec ESP32 et RTC DS1307 (I2C + LCD)
ES-18Intermédiaire
Premium

Horloge numérique avec ESP32 et RTC DS1307 (I2C + LCD)

Dans ce projet, nous affichons l'heure et la date sur un écran LCD 16x2 I2C à l'aide du module d'horloge en temps réel (RTC) DS1307. Le DS1307 est une RTC avec batterie de secours qui conserve l'heure même si l'ESP32 s'éteint. Les deux modules partagent la même ligne I2C (SDA/SCL), ce qui nous permet d'apprendre à contrôler plusieurs appareils avec seulement deux fils de signal. Vous decouvrirez ainsi le protocole I2C et le fonctionnement des modules RTC en pratique.

4.6(26)
40
ESP32 : heure réelle depuis Internet via NTP
ES-26Avancé
Premium

ESP32 : heure réelle depuis Internet via NTP

L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

4.5(13)
22
Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avancé
Premium

Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)

Une alarme de sécurité intelligente : quand le capteur PIR détecte un mouvement, le buzzer sonne, la LED s'allume et le propriétaire reçoit aussitôt une notification Telegram. Un délai de 30 secondes (cooldown) limite la répétition des alarmes ; il n'élimine pas les fausses détections du capteur PIR. À utiliser à la maison, au garage, dans une réserve ou un bureau.

9