Control de acceso a la comida para gatos (ESP8266 + servomotor + impresión 3D): 5 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Este proyecto repasa el proceso que utilicé para crear un tazón de comida para gatos automatizado, para mi gato anciano diabético Chaz. Mira, necesita desayunar antes de que pueda recibir su insulina, pero a menudo me olvido de recoger su plato de comida antes de irme a la cama, lo que arruina su apetito y altera su horario de insulina. Este plato utiliza un servomotor para cerrar una tapa sobre la comida entre la medianoche y las 7:30 am. El boceto Arduino del microcontrolador NodeMCU ESP8266 usa el Protocolo de tiempo de red (NTP) para controlar la programación.

Es posible que este proyecto no sea adecuado para gatos más jóvenes y activos. Chaz es tan viejo y frágil que no está dispuesto a intentar abrir el cuenco, pero es posible.

Si es nuevo en Arduino o ESP8266, puede disfrutar de las siguientes guías de requisitos previos:

• Instructables Clase Arduino
• Clase de Instructables Internet de las cosas

Suministros

• Impresora 3D (yo uso una Creality CR-10s Pro)
• Filamento de impresora 3D (estoy usando PLA dorado)
• Microcontrolador wifi NodeMCU ESP8266
• Cable USB (A a microB)
• Adaptador de corriente USB
• Micro servomotor
• Destornillador pequeño y tornillos
• Conectar cable
• Pines de encabezado
• Tablero perma-proto

Para estar al día en lo que estoy trabajando, sígueme en YouTube, Instagram, Twitter, Pinterest y suscríbete a mi boletín. Como Asociado de Amazon, gano por las compras que califiquen que realice utilizando mis enlaces de afiliados.

Paso 1: Piezas impresas en 3D

El soporte para tazón de comida para gatos se basa en el diseño de Ardy Lai en Thingiverse. Lo hice más grande para acomodar el cuenco de mi gato, y también lo hice más corto ya que escalarlo lo había hecho demasiado alto. Agregué un soporte para un micro servomotor y un par de orificios para que los cables se dirijan hacia el interior.

Modelé una tapa simple usando Tinkercad, diseñada para acoplarse a la bocina del micro servo. Puede tomar mi diseño directamente de Tinkercad y / o descargar los STL adjuntos a este paso.

Imprimí las piezas en mi impresora Creality CR-10s Pro con filamento PLA dorado.

Divulgación: en el momento de escribir este artículo, soy un empleado de Autodesk, que fabrica Tinkercad.

Paso 2: coloque la tapa en el servomotor

Usé una pequeña broca para aumentar el tamaño de los orificios en la bocina del servo, luego usé tornillos para sujetar el servo a la tapa impresa en 3D.

Paso 3: Construya el circuito NodeMCU ESP8266

El circuito está controlado por un microcontrolador wifi NodeMCU ESP8266. Usé pines de encabezado en una placa perma-proto para hacer que el micro servo motor se desmontara fácilmente. Los encabezados de servo están conectados al NodeMCU de la siguiente manera:

Cable servo amarillo: NodeMCU D1

Cable servo rojo: potencia NodeMCU (3V3 o VIN)

Cable servo negro: tierra NodeMCU (GND)

Paso 4: Cargue el código Arduino y pruebe

Instale su conjunto de motor / tapa en el corte en forma de motor en la pieza impresa en 3D del soporte del tazón. Enchufe el cabezal del motor en los pines del cabezal de la placa del microcontrolador y conecte el circuito a su computadora con un cable USB.

El boceto de Arduino utiliza el Protocolo de tiempo de red para obtener la hora actual y luego abre o cierra la tapa de acuerdo con un programa codificado. Copie el siguiente código, actualice sus credenciales wifi y la diferencia horaria UTC, y cárguelo en su placa NodeMCU utilizando el IDE de Arduino.

#incluir

#incluye #include #include ESP8266WiFiMulti wifiMulti; // Cree una instancia de la clase ESP8266WiFiMulti, llamada 'wifiMulti' WiFiUDP UDP; // Cree una instancia de la clase WiFiUDP para enviar y recibir IPAddress timeServerIP; // time.nist.gov dirección del servidor NTP const char * NTPServerName = "time.nist.gov"; const int NTP_PACKET_SIZE = 48; // La marca de tiempo NTP está en los primeros 48 bytes del byte de mensaje NTPBuffer [NTP_PACKET_SIZE]; // búfer para contener paquetes entrantes y salientes Servo myservo; // crea un objeto servo para controlar un servo // se pueden crear doce objetos servo en la mayoría de las placas int pos = 0; // variable para almacenar la posición del servo void setup () {myservo.attach (5); // conecta el servo en el pin 5, también conocido como D1, al objeto servo // abre la tapa por defecto Serial.println ("abriendo la tapa"); for (pos = 95; pos> = 0; pos - = 1) {// va de 95 grados a 0 grados myservo.write (pos); // le dice al servo que vaya a la posición en la variable 'pos' delay (15); // espera 15ms a que el servo alcance la posición} Serial.begin (115200); // Inicia la comunicación serial para enviar mensajes a la computadora delay (10); Serial.println ("\ r / n"); startWiFi (); // Intente conectarse a algunos puntos de acceso dados. Luego espere una conexión startUDP (); if (! WiFi.hostByName (NTPServerName, timeServerIP)) {// Obtenga la dirección IP del servidor NTP Serial.println ("Falló la búsqueda de DNS. Reiniciando."); Serial.flush (); ESP.reset (); } Serial.print ("IP del servidor de tiempo: / t"); Serial.println (timeServerIP); Serial.println ("\ r / nEnviando solicitud NTP…"); sendNTPpacket (timeServerIP); } intervalo largo sin firmar NTP = 60000; // Solicitar tiempo NTP cada minuto unsigned long prevNTP = 0; unsigned long lastNTPResponse = millis (); uint32_t timeUNIX = 0; unsigned long prevActualTime = 0; bucle vacío () {currentMillis largo sin firmar = millis (); if (currentMillis - prevNTP> intervalNTP) {// Si ha pasado un minuto desde la última solicitud de NTP prevNTP = currentMillis; Serial.println ("\ r / nEnviando solicitud NTP…"); sendNTPpacket (timeServerIP); // Envía una solicitud NTP} uint32_t time = getTime (); // Compruebe si ha llegado una respuesta NTP y obtenga la hora (UNIX) if (time) {// Si se ha recibido una nueva marca de tiempo timeUNIX = time; Serial.print ("Respuesta NTP: / t"); Serial.println (timeUNIX); lastNTPResponse = currentMillis; } else if ((currentMillis - lastNTPResponse)> 3600000) {Serial.println ("Más de 1 hora desde la última respuesta NTP. Reiniciando."); Serial.flush (); ESP.reset (); } uint32_t actualTime = timeUNIX + (currentMillis - lastNTPResponse) / 1000; uint32_t EasternTime = timeUNIX - 18000 + (currentMillis - lastNTPResponse) / 1000; if (actualTime! = prevActualTime && timeUNIX! = 0) {// Si ha pasado un segundo desde la última impresión prevActualTime = actualTime; Serial.printf ("\ rUTC time: / t% d:% d:% d", getHours (actualTime), getMinutes (actualTime), getSeconds (actualTime)); Serial.printf ("\ rEST (-5): / t% d:% d:% d", getHours (EasternTime), getMinutes (EasternTime), getSeconds (EasternTime)); Serial.println (); } // 7:30 am if (getHours (EasternTime) == 7 && getMinutes (EasternTime) == 30 && getSeconds (EasternTime) == 0) {// abre la tapa Serial.println ("abriendo la tapa"); for (pos = 95; pos> = 0; pos - = 1) {// va de 95 grados a 0 grados myservo.write (pos); // le dice al servo que vaya a la posición en la variable 'pos' delay (15); // espera 15ms para que el servo alcance la posición}} // medianoche if (getHours (EasternTime) == 0 && getMinutes (EasternTime) == 0 && getSeconds (easternTime) == 0) {// cierra la tapa Serial. println ("cerrando la tapa"); for (pos = 0; pos <= 95; pos + = 1) {// va de 0 grados a 95 grados // en pasos de 1 grado myservo.write (pos); // le dice al servo que vaya a la posición en la variable 'pos' delay (15); // espera 15ms para que el servo alcance la posición}} / * // probando if (getHours (EasternTime) == 12 && getMinutes (EasternTime) == 45 && getSeconds (easternTime) == 0) {// cierra la tapa Serial.println ("cerrando la tapa"); for (pos = 0; pos = 0; pos - = 1) {// va de 95 grados a 0 grados myservo.write (pos); // le dice al servo que vaya a la posición en la variable 'pos' delay (15); // espera 15ms a que el servo alcance la posición}} * /} void startWiFi () {// Intenta conectarte a algunos puntos de acceso dados. Luego espere una conexión wifiMulti.addAP ("ssid_from_AP_1", "your_password_for_AP_1"); // agregue las redes Wi-Fi a las que desea conectarse //wifiMulti.addAP("ssid_from_AP_2 "," your_password_for_AP_2 "); //wifiMulti.addAP("ssid_from_AP_3 "," your_password_for_AP_3 "); Serial.println ("Conectando"); while (wifiMulti.run ()! = WL_CONNECTED) {// Espere a que el Wi-Fi se conecte delay (250); Serial.print ('.'); } Serial.println ("\ r / n"); Serial.print ("Conectado a"); Serial.println (WiFi. SSID ()); // Dinos a qué red estamos conectados Serial.print ("IP address: / t"); Serial.print (WiFi.localIP ()); // Envíe la dirección IP del ESP8266 a la computadora Serial.println ("\ r / n"); } void startUDP () {Serial.println ("Iniciando UDP"); UDP.begin (123); // Empiece a escuchar mensajes UDP en el puerto 123 Serial.print ("Puerto local: / t"); Serial.println (UDP.localPort ()); Serial.println (); } uint32_t getTime () {if (UDP.parsePacket () == 0) {// Si no hay respuesta (todavía) devuelve 0; } UDP.read (NTPBuffer, NTP_PACKET_SIZE); // lee el paquete en el búfer // Combina los 4 bytes de marca de tiempo en un número de 32 bits uint32_t NTPTime = (NTPBuffer [40] << 24) | (NTPBuffer [41] << 16) | (NTPBuffer [42] << 8) | NTPBuffer [43]; // Convierta la hora NTP en una marca de tiempo UNIX: // La hora Unix comienza el 1 de enero de 1970. Eso es 2208988800 segundos en tiempo NTP: const uint32_t setenta años = 2208988800UL; // reste setenta años: uint32_t UNIXTime = NTPTime - setenta años; return UNIXTime; } vacío sendNTPpacket (dirección IP y dirección) {memset (NTPBuffer, 0, NTP_PACKET_SIZE); // establece todos los bytes en el búfer en 0 // Inicializa los valores necesarios para formar la solicitud NTP NTPBuffer [0] = 0b11100011; // LI, Versión, Modo // envía un paquete solicitando una marca de tiempo: UDP.beginPacket (dirección, 123); // Las solicitudes NTP son al puerto 123 UDP.write (NTPBuffer, NTP_PACKET_SIZE); UDP.endPacket (); } inline int getSeconds (uint32_t UNIXTime) {return UNIXTime% 60; } inline int getMinutes (uint32_t UNIXTime) {return UNIXTime / 60% 60; } inline int getHours (uint32_t UNIXTime) {return UNIXTime / 3600% 24; }

Paso 5: ¡Úselo

Dirija los cables hacia el interior del soporte del tazón y conecte el comedero para gatos a un tomacorriente con un adaptador de CA USB. La forma en que se escribe el código simple, debe iniciarse en el estado "abierto" y solo cambiará la posición de la tapa en los umbrales de tiempo especificados en el boceto de Arduino.

¡Gracias por seguirnos! Si crea su propia versión, ¡me encantaría verla en la sección I Made It a continuación!

Si te gusta este proyecto, puede que te interesen algunos de mis otros:

• Soporte de prisma para retratos de arcoíris
• Pared de almacenamiento de madera contrachapada con torre para gatos
• Linternas LED Mason Jar (tapa impresa en 3D)
• Caja seca de filamento de impresora 3D
• Fuente de alimentación USB de emergencia (impresa en 3D)
• Caramelo gomoso LED que brilla intensamente
• Jardinera geométrica impresa en 3D con drenaje
• Flores impresas en 3D que brillan intensamente
• Cómo instalar LED debajo de un scooter (con Bluetooth)

Para estar al día en lo que estoy trabajando, sígueme en YouTube, Instagram, Twitter y Pinterest.